././@PaxHeader0000000000000000000000000000003400000000000010212 xustar0028 mtime=1714685833.3694384 astroscrappy-1.2.0/0000755000175100001770000000000014615003611013646 5ustar00runnerdocker././@PaxHeader0000000000000000000000000000003400000000000010212 xustar0028 mtime=1714685833.3574383 astroscrappy-1.2.0/.github/0000755000175100001770000000000014615003611015206 5ustar00runnerdocker././@PaxHeader0000000000000000000000000000003400000000000010212 xustar0028 mtime=1714685833.3574383 astroscrappy-1.2.0/.github/workflows/0000755000175100001770000000000014615003611017243 5ustar00runnerdocker././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1714685814.0 astroscrappy-1.2.0/.github/workflows/python-tests.yml0000644000175100001770000000470714615003566022470 0ustar00runnerdockername: Run unit tests on: push: pull_request: workflow_dispatch: concurrency: group: ${{ github.workflow }}-${{ github.ref }} cancel-in-progress: true jobs: tests: name: ${{ matrix.name }} (${{ matrix.os }}, ${{ matrix.toxenv }}) runs-on: ${{ matrix.os }} if: "!(contains(github.event.head_commit.message, '[skip ci]') || contains(github.event.head_commit.message, '[ci skip]'))" strategy: fail-fast: false matrix: include: - name: Python 3.9 with required dependencies os: windows-latest python-version: 3.9 toxenv: py39-test-numpy122 - name: Python 3.10 with required dependencies os: ubuntu-latest python-version: "3.10" toxenv: py310-test-numpy124 - name: Python 3.11 with required dependencies os: macos-latest python-version: "3.11" toxenv: py311-test-astropy53 - name: Python 3.12 with required dependencies os: ubuntu-latest python-version: "3.12" toxenv: py312-test coverage: true - name: Code style checks os: ubuntu-latest python-version: "3.12" toxenv: codestyle steps: - uses: actions/checkout@v4 with: fetch-depth: 0 - name: Set up Python ${{ matrix.python-version }} uses: actions/setup-python@v5 with: python-version: ${{ matrix.python-version }} - name: Install dependencies run: python -m pip install tox - name: Run tests if: "! matrix.coverage" run: tox -v -e ${{ matrix.toxenv }} - name: Run tests with coverage if: "matrix.coverage" run: | pip install Cython extension-helpers numpy COVERAGE=1 pip install -e .[test] pytest --pyargs astroscrappy docs --cov astroscrappy - name: Upload coverage to codecov if: "matrix.coverage" run: | pip install codecov codecov publish: needs: tests uses: OpenAstronomy/github-actions-workflows/.github/workflows/publish.yml@v1 with: test_extras: test test_command: pytest -p no:warnings --pyargs astroscrappy targets: | - cp*-manylinux_x86_64 - cp*-manylinux_aarch64 - cp*-macosx_x86_64 - cp*-macosx_arm64 - cp*-win_amd64 secrets: pypi_token: ${{ secrets.pypi_token }} anaconda_token: ${{ secrets.anaconda_token }} ././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1714685814.0 astroscrappy-1.2.0/.gitignore0000644000175100001770000000134114615003566015646 0ustar00runnerdocker# Compiled files *.py[cod] *.a *.o *.so a.out __pycache__ .idea # Ignore .c files by default to avoid including generated code. If you want to # add a non-generated .c extension, use `git add -f filename.c`. *.c # Other generated files */version.py */cython_version.py htmlcov .coverage MANIFEST .ipynb_checkpoints # Sphinx docs/api docs/_build # Eclipse editor project files .project .pydevproject .settings # Pycharm editor project files .idea # Floobits project files .floo .flooignore # Packages/installer info *.egg *.egg-info dist build eggs .eggs parts bin var sdist develop-eggs .installed.cfg distribute-*.tar.gz # Other .cache .tox .*.sw[op] *~ .project .pydevproject .settings pip-wheel-metadata/ # Mac OSX .DS_Store ././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1714685814.0 astroscrappy-1.2.0/.readthedocs.yml0000644000175100001770000000025214615003566016744 0ustar00runnerdockerversion: 2 build: image: latest python: version: 3.7 install: - method: pip path: . extra_requirements: - docs - all formats: [] ././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1714685814.0 astroscrappy-1.2.0/CHANGES.rst0000644000175100001770000000266714615003566015474 0ustar00runnerdocker1.2.0 (2024-05-02) ------------------ - Updated package infrastructure. - Fixed compatibility with Numpy 2.0 and recent versions of SciPy. - The minimum supported version of Python is now 3.9. - Change to normalization for convolution fine structure method to instead use a matched filter. 1.1.0 (2021-11-19) ------------------ - Added the option to add a variance array - Added the ability to subtract a background array rather than a single value. - To accommodate these changes, we now return the cleaned array in the same units as the user provides, ADU rather than electrons and with the background included. 1.0.5 (2016-08-16) ------------------ - Updated to newest version of astropy package template. - Fixed median cleaning. There was a subtle bug that the crmask was defined as a unit8 array. This was then used to clean the image, but this acted as indexes 0 and 1 rather than a boolean array that was intended 1.0.4 (2016-02-29) ------------------ - Fixed setup_requires so that it doesn't install astropy when using egg_info. - Pinned coverage version to 3.7.1. - Removed dependence on endianness in tests - Fixed build issues on windows 1.0.3 (2015-09-29) ------------------ - Updated URL in setup.cfg. 1.0.2 (2015-09-29) ------------------ - Added .h files to MANIFEST.in 1.0.1 (2015-09-29) ------------------ - Fixed bug in MANIFEST.in that was excluding *.pyx files. 1.0 (2015-09-29) ---------------- - Initial release. ././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1714685814.0 astroscrappy-1.2.0/MANIFEST.in0000644000175100001770000000066514615003566015424 0ustar00runnerdockerinclude README.rst include CHANGES.rst include setup.cfg include LICENSE.rst include pyproject.toml include astroscrappy/tests/coveragerc recursive-exclude . astroscrappy.c recursive-exclude astroscrappy/utils image_utils.c median_utils.c recursive-include astroscrappy *.pyx *.pxd recursive-include docs * recursive-include licenses * recursive-include scripts * prune build prune docs/_build prune docs/api global-exclude *.pyc *.o ././@PaxHeader0000000000000000000000000000003400000000000010212 xustar0028 mtime=1714685833.3694384 astroscrappy-1.2.0/PKG-INFO0000644000175100001770000000700714615003611014747 0ustar00runnerdockerMetadata-Version: 2.1 Name: astroscrappy Version: 1.2.0 Summary: Speedy Cosmic Ray Annihilation Package in Python Author-email: Curtis McCully License: BSD-3-Clause Project-URL: Homepage, https://github.com/astropy/astroscrappy Requires-Python: >=3.9 Description-Content-Type: text/x-rst License-File: licenses/LICENSE.rst Requires-Dist: astropy Requires-Dist: numpy Provides-Extra: docs Requires-Dist: sphinx-astropy; extra == "docs" Provides-Extra: test Requires-Dist: Cython; extra == "test" Requires-Dist: pytest-astropy; extra == "test" Requires-Dist: scipy; extra == "test" Astro-SCRAPPY: The Speedy Cosmic Ray Annihilation Package in Python =================================================================== .. image:: https://readthedocs.org/projects/astroscrappy/badge/?version=latest :alt: Documentation Status :scale: 100% :target: https://astroscrappy.readthedocs.io/en/latest/?badge=latest .. image:: https://github.com/astropy/astroscrappy/workflows/Run%20unit%20tests/badge.svg :target: https://github.com/astropy/astroscrappy/actions :alt: CI Status .. image:: https://codecov.io/gh/astropy/astroscrappy/branch/main/graph/badge.svg :target: https://codecov.io/gh/astropy/astroscrappy :alt: AstroScrappy's Coverage Status .. image:: https://zenodo.org/badge/36837126.svg :target: https://zenodo.org/badge/latestdoi/36837126 An optimized cosmic ray detector. :Author: Curtis McCully Astro-SCRAPPY is designed to detect cosmic rays in images (numpy arrays), based on Pieter van Dokkum's L.A.Cosmic algorithm. Much of this was originally adapted from cosmics.py written by Malte Tewes. I have ported all of the slow functions to Cython/C, and optimized where I can. This is designed to be as fast as possible so some of the readability has been sacrificed, specifically in the C code. If you use this code, please cite the Zendo DOI: https://zenodo.org/record/1482019 Please cite the original paper which can be found at: http://www.astro.yale.edu/dokkum/lacosmic/ van Dokkum 2001, PASP, 113, 789, 1420 (article : http://adsabs.harvard.edu/abs/2001PASP..113.1420V) This code requires Cython, preferably version >= 0.21. Parallelization is achieved using OpenMP. This code should compile (although the Cython files may have issues) using a compiler that does not support OMP, e.g. clang. Notes ----- There are some differences from original LA Cosmic: - Automatic recognition of saturated stars. This avoids treating such stars as large cosmic rays. - I have tried to optimize all of the code as much as possible while maintaining the integrity of the algorithm. One of the key speedups is to use a separable median filter instead of the true median filter. While these are not identical, they produce comparable results and the separable version is much faster. - This implementation is much faster than the Python by as much as a factor of ~17 depending on the given parameters, even without running multiple threads. With multiple threads, this can be increased easily by another factor of 2. This implementation is much faster than the original IRAF version, improvment by a factor of ~90. The arrays always must be C-contiguous, thus all loops are y outer, x inner. This follows the astropy.io.fits (pyfits) convention. scipy is required for certain tests to pass, but the code itself does not depend on scipy. License ------- This project is Copyright (c) Astropy Developers and licensed under the terms of the BSD 3-Clause license. See the licenses folder for more information. ././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1714685814.0 astroscrappy-1.2.0/README.rst0000644000175100001770000000565414615003566015360 0ustar00runnerdockerAstro-SCRAPPY: The Speedy Cosmic Ray Annihilation Package in Python =================================================================== .. image:: https://readthedocs.org/projects/astroscrappy/badge/?version=latest :alt: Documentation Status :scale: 100% :target: https://astroscrappy.readthedocs.io/en/latest/?badge=latest .. image:: https://github.com/astropy/astroscrappy/workflows/Run%20unit%20tests/badge.svg :target: https://github.com/astropy/astroscrappy/actions :alt: CI Status .. image:: https://codecov.io/gh/astropy/astroscrappy/branch/main/graph/badge.svg :target: https://codecov.io/gh/astropy/astroscrappy :alt: AstroScrappy's Coverage Status .. image:: https://zenodo.org/badge/36837126.svg :target: https://zenodo.org/badge/latestdoi/36837126 An optimized cosmic ray detector. :Author: Curtis McCully Astro-SCRAPPY is designed to detect cosmic rays in images (numpy arrays), based on Pieter van Dokkum's L.A.Cosmic algorithm. Much of this was originally adapted from cosmics.py written by Malte Tewes. I have ported all of the slow functions to Cython/C, and optimized where I can. This is designed to be as fast as possible so some of the readability has been sacrificed, specifically in the C code. If you use this code, please cite the Zendo DOI: https://zenodo.org/record/1482019 Please cite the original paper which can be found at: http://www.astro.yale.edu/dokkum/lacosmic/ van Dokkum 2001, PASP, 113, 789, 1420 (article : http://adsabs.harvard.edu/abs/2001PASP..113.1420V) This code requires Cython, preferably version >= 0.21. Parallelization is achieved using OpenMP. This code should compile (although the Cython files may have issues) using a compiler that does not support OMP, e.g. clang. Notes ----- There are some differences from original LA Cosmic: - Automatic recognition of saturated stars. This avoids treating such stars as large cosmic rays. - I have tried to optimize all of the code as much as possible while maintaining the integrity of the algorithm. One of the key speedups is to use a separable median filter instead of the true median filter. While these are not identical, they produce comparable results and the separable version is much faster. - This implementation is much faster than the Python by as much as a factor of ~17 depending on the given parameters, even without running multiple threads. With multiple threads, this can be increased easily by another factor of 2. This implementation is much faster than the original IRAF version, improvment by a factor of ~90. The arrays always must be C-contiguous, thus all loops are y outer, x inner. This follows the astropy.io.fits (pyfits) convention. scipy is required for certain tests to pass, but the code itself does not depend on scipy. License ------- This project is Copyright (c) Astropy Developers and licensed under the terms of the BSD 3-Clause license. See the licenses folder for more information. ././@PaxHeader0000000000000000000000000000003400000000000010212 xustar0028 mtime=1714685833.3614383 astroscrappy-1.2.0/astroscrappy/0000755000175100001770000000000014615003611016400 5ustar00runnerdocker././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1714685814.0 astroscrappy-1.2.0/astroscrappy/__init__.py0000644000175100001770000000444714615003566020533 0ustar00runnerdocker# Licensed under a 3-clause BSD style license - see LICENSE.rst """ Astro-SCRAPPY: The Speedy Cosmic Ray Annihilation Package in Python =================================================================== An optimized cosmic ray detector :Author: Curtis McCully Astro-SCRAPPY is designed to detect cosmic rays in images (numpy arrays), originally based on Pieter van Dokkum's L.A.Cosmic algorithm. Much of this was originally adapted from cosmics.py written by Malte Tewes. I have ported all of the slow functions to Cython/C, and optimized where I can. This is designed to be as fast as possible so some of the readability has been sacrificed, specifically in the C code. L.A.Cosmic = LAplacian Cosmic ray detection If you use this code, please cite the Zendo DOI: https://zenodo.org/record/1482019 Please cite the original paper which can be found at: http://www.astro.yale.edu/dokkum/lacosmic/ van Dokkum 2001, PASP, 113, 789, 1420 (article : http://adsabs.harvard.edu/abs/2001PASP..113.1420V) This code requires Cython, preferably version >= 0.21. Parallelization is achieved using OpenMP. This code should compile (although the Cython files may have issues) using a compiler that does not support OMP, e.g. clang. Notes ----- There are some differences from original LACosmic: - Automatic recognition of saturated stars. This avoids treating such stars as large cosmic rays. - I have tried to optimize all of the code as much as possible while maintaining the integrity of the algorithm. One of the key speedups is to use a separable median filter instead of the true median filter. While these are not identical, they produce comparable results and the separable version is much faster. - This implementation is much faster than the Python by as much as a factor of 28 depending on the given parameters. This implementation is much faster than the original IRAF version, by a factor of ~90. Note that arrays always must be C-contiguous, thus all loops are y outer, x inner. This follows the Pyfits convention. scipy is required for certain tests to pass, but the code itself does not depend on scipy. """ from .astroscrappy import * # noqa from .utils import * # noqa from .version import version as __version__ # noqa __all__ = ['detect_cosmics'] # noqa ././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1714685833.0 astroscrappy-1.2.0/astroscrappy/_compiler.c0000644000175100001770000000524014615003611020516 0ustar00runnerdocker#include /*************************************************************************** * Macros for determining the compiler version. * * These are borrowed from boost, and majorly abridged to include only * the compilers we care about. ***************************************************************************/ #define STRINGIZE(X) DO_STRINGIZE(X) #define DO_STRINGIZE(X) #X #if defined __clang__ /* Clang C++ emulates GCC, so it has to appear early. */ # define COMPILER "Clang version " __clang_version__ #elif defined(__INTEL_COMPILER) || defined(__ICL) || defined(__ICC) || defined(__ECC) /* Intel */ # if defined(__INTEL_COMPILER) # define INTEL_VERSION __INTEL_COMPILER # elif defined(__ICL) # define INTEL_VERSION __ICL # elif defined(__ICC) # define INTEL_VERSION __ICC # elif defined(__ECC) # define INTEL_VERSION __ECC # endif # define COMPILER "Intel C compiler version " STRINGIZE(INTEL_VERSION) #elif defined(__GNUC__) /* gcc */ # define COMPILER "GCC version " __VERSION__ #elif defined(__SUNPRO_CC) /* Sun Workshop Compiler */ # define COMPILER "Sun compiler version " STRINGIZE(__SUNPRO_CC) #elif defined(_MSC_VER) /* Microsoft Visual C/C++ Must be last since other compilers define _MSC_VER for compatibility as well */ # if _MSC_VER < 1200 # define COMPILER_VERSION 5.0 # elif _MSC_VER < 1300 # define COMPILER_VERSION 6.0 # elif _MSC_VER == 1300 # define COMPILER_VERSION 7.0 # elif _MSC_VER == 1310 # define COMPILER_VERSION 7.1 # elif _MSC_VER == 1400 # define COMPILER_VERSION 8.0 # elif _MSC_VER == 1500 # define COMPILER_VERSION 9.0 # elif _MSC_VER == 1600 # define COMPILER_VERSION 10.0 # else # define COMPILER_VERSION _MSC_VER # endif # define COMPILER "Microsoft Visual C++ version " STRINGIZE(COMPILER_VERSION) #else /* Fallback */ # define COMPILER "Unknown compiler" #endif /*************************************************************************** * Module-level ***************************************************************************/ struct module_state { /* The Sun compiler can't handle empty structs */ #if defined(__SUNPRO_C) || defined(_MSC_VER) int _dummy; #endif }; static struct PyModuleDef moduledef = { PyModuleDef_HEAD_INIT, "compiler_version", NULL, sizeof(struct module_state), NULL, NULL, NULL, NULL, NULL }; #define INITERROR return NULL PyMODINIT_FUNC PyInit_compiler_version(void) { PyObject* m; m = PyModule_Create(&moduledef); if (m == NULL) INITERROR; PyModule_AddStringConstant(m, "compiler", COMPILER); return m; } ././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1714685831.0 astroscrappy-1.2.0/astroscrappy/astroscrappy.c0000644000175100001770000572222314615003607021320 0ustar00runnerdocker/* Generated by Cython 3.0.10 */ /* BEGIN: Cython Metadata { "distutils": { "define_macros": [ [ "NPY_NO_DEPRECATED_API", "NPY_1_7_API_VERSION" ] ], "depends": [ "/tmp/build-env-2vlxkjf_/lib/python3.12/site-packages/numpy/_core/include/numpy/arrayobject.h", "/tmp/build-env-2vlxkjf_/lib/python3.12/site-packages/numpy/_core/include/numpy/arrayscalars.h", "/tmp/build-env-2vlxkjf_/lib/python3.12/site-packages/numpy/_core/include/numpy/ndarrayobject.h", "/tmp/build-env-2vlxkjf_/lib/python3.12/site-packages/numpy/_core/include/numpy/ndarraytypes.h", "/tmp/build-env-2vlxkjf_/lib/python3.12/site-packages/numpy/_core/include/numpy/ufuncobject.h" ], "include_dirs": [ "/tmp/build-env-2vlxkjf_/lib/python3.12/site-packages/numpy/_core/include" ], "name": "astroscrappy.astroscrappy", "sources": [ "astroscrappy/astroscrappy.pyx" ] }, "module_name": "astroscrappy.astroscrappy" } END: Cython Metadata */ #ifndef PY_SSIZE_T_CLEAN #define PY_SSIZE_T_CLEAN #endif /* PY_SSIZE_T_CLEAN */ #if defined(CYTHON_LIMITED_API) && 0 #ifndef Py_LIMITED_API #if CYTHON_LIMITED_API+0 > 0x03030000 #define Py_LIMITED_API CYTHON_LIMITED_API #else #define Py_LIMITED_API 0x03030000 #endif #endif #endif #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 < 0x02070000 || (0x03000000 <= PY_VERSION_HEX && PY_VERSION_HEX < 0x03030000) #error Cython requires Python 2.7+ or Python 3.3+. #else #if defined(CYTHON_LIMITED_API) && CYTHON_LIMITED_API #define __PYX_EXTRA_ABI_MODULE_NAME "limited" #else #define __PYX_EXTRA_ABI_MODULE_NAME "" #endif #define CYTHON_ABI "3_0_10" __PYX_EXTRA_ABI_MODULE_NAME #define __PYX_ABI_MODULE_NAME "_cython_" CYTHON_ABI #define __PYX_TYPE_MODULE_PREFIX __PYX_ABI_MODULE_NAME "." #define CYTHON_HEX_VERSION 0x03000AF0 #define CYTHON_FUTURE_DIVISION 1 #include #ifndef offsetof #define offsetof(type, member) ( (size_t) & ((type*)0) -> member ) #endif #if !defined(_WIN32) && !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 #define HAVE_LONG_LONG #endif #ifndef PY_LONG_LONG #define PY_LONG_LONG LONG_LONG #endif #ifndef Py_HUGE_VAL #define Py_HUGE_VAL HUGE_VAL #endif #define __PYX_LIMITED_VERSION_HEX PY_VERSION_HEX #if defined(GRAALVM_PYTHON) /* For very preliminary testing purposes. Most variables are set the same as PyPy. The existence of this section does not imply that anything works or is even tested */ #define CYTHON_COMPILING_IN_PYPY 0 #define CYTHON_COMPILING_IN_CPYTHON 0 #define CYTHON_COMPILING_IN_LIMITED_API 0 #define CYTHON_COMPILING_IN_GRAAL 1 #define CYTHON_COMPILING_IN_NOGIL 0 #undef CYTHON_USE_TYPE_SLOTS #define CYTHON_USE_TYPE_SLOTS 0 #undef CYTHON_USE_TYPE_SPECS #define CYTHON_USE_TYPE_SPECS 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_GIL #define CYTHON_FAST_GIL 0 #undef CYTHON_METH_FASTCALL #define CYTHON_METH_FASTCALL 0 #undef CYTHON_FAST_PYCALL #define CYTHON_FAST_PYCALL 0 #ifndef CYTHON_PEP487_INIT_SUBCLASS #define CYTHON_PEP487_INIT_SUBCLASS (PY_MAJOR_VERSION >= 3) #endif #undef CYTHON_PEP489_MULTI_PHASE_INIT #define CYTHON_PEP489_MULTI_PHASE_INIT 1 #undef CYTHON_USE_MODULE_STATE #define CYTHON_USE_MODULE_STATE 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 #undef CYTHON_USE_FREELISTS #define CYTHON_USE_FREELISTS 0 #elif defined(PYPY_VERSION) #define CYTHON_COMPILING_IN_PYPY 1 #define CYTHON_COMPILING_IN_CPYTHON 0 #define CYTHON_COMPILING_IN_LIMITED_API 0 #define CYTHON_COMPILING_IN_GRAAL 0 #define CYTHON_COMPILING_IN_NOGIL 0 #undef CYTHON_USE_TYPE_SLOTS #define CYTHON_USE_TYPE_SLOTS 0 #ifndef CYTHON_USE_TYPE_SPECS #define CYTHON_USE_TYPE_SPECS 0 #endif #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_GIL #define CYTHON_FAST_GIL 0 #undef CYTHON_METH_FASTCALL #define CYTHON_METH_FASTCALL 0 #undef CYTHON_FAST_PYCALL #define CYTHON_FAST_PYCALL 0 #ifndef CYTHON_PEP487_INIT_SUBCLASS #define CYTHON_PEP487_INIT_SUBCLASS (PY_MAJOR_VERSION >= 3) #endif #if PY_VERSION_HEX < 0x03090000 #undef CYTHON_PEP489_MULTI_PHASE_INIT #define CYTHON_PEP489_MULTI_PHASE_INIT 0 #elif !defined(CYTHON_PEP489_MULTI_PHASE_INIT) #define CYTHON_PEP489_MULTI_PHASE_INIT 1 #endif #undef CYTHON_USE_MODULE_STATE #define CYTHON_USE_MODULE_STATE 0 #undef CYTHON_USE_TP_FINALIZE #define CYTHON_USE_TP_FINALIZE (PY_VERSION_HEX >= 0x030400a1 && PYPY_VERSION_NUM >= 0x07030C00) #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 #undef CYTHON_USE_FREELISTS #define CYTHON_USE_FREELISTS 0 #elif defined(CYTHON_LIMITED_API) #ifdef Py_LIMITED_API #undef __PYX_LIMITED_VERSION_HEX #define __PYX_LIMITED_VERSION_HEX Py_LIMITED_API #endif #define CYTHON_COMPILING_IN_PYPY 0 #define CYTHON_COMPILING_IN_CPYTHON 0 #define CYTHON_COMPILING_IN_LIMITED_API 1 #define CYTHON_COMPILING_IN_GRAAL 0 #define CYTHON_COMPILING_IN_NOGIL 0 #undef CYTHON_CLINE_IN_TRACEBACK #define CYTHON_CLINE_IN_TRACEBACK 0 #undef CYTHON_USE_TYPE_SLOTS #define CYTHON_USE_TYPE_SLOTS 0 #undef CYTHON_USE_TYPE_SPECS #define CYTHON_USE_TYPE_SPECS 1 #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 #undef CYTHON_USE_UNICODE_INTERNALS #define CYTHON_USE_UNICODE_INTERNALS 0 #ifndef CYTHON_USE_UNICODE_WRITER #define CYTHON_USE_UNICODE_WRITER 0 #endif #undef CYTHON_USE_PYLONG_INTERNALS #define CYTHON_USE_PYLONG_INTERNALS 0 #ifndef CYTHON_AVOID_BORROWED_REFS #define CYTHON_AVOID_BORROWED_REFS 0 #endif #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_GIL #define CYTHON_FAST_GIL 0 #undef CYTHON_METH_FASTCALL #define CYTHON_METH_FASTCALL 0 #undef CYTHON_FAST_PYCALL #define CYTHON_FAST_PYCALL 0 #ifndef CYTHON_PEP487_INIT_SUBCLASS #define CYTHON_PEP487_INIT_SUBCLASS 1 #endif #undef CYTHON_PEP489_MULTI_PHASE_INIT #define CYTHON_PEP489_MULTI_PHASE_INIT 0 #undef CYTHON_USE_MODULE_STATE #define CYTHON_USE_MODULE_STATE 1 #ifndef CYTHON_USE_TP_FINALIZE #define CYTHON_USE_TP_FINALIZE 0 #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 #ifndef CYTHON_UPDATE_DESCRIPTOR_DOC #define CYTHON_UPDATE_DESCRIPTOR_DOC 0 #endif #undef CYTHON_USE_FREELISTS #define CYTHON_USE_FREELISTS 0 #elif defined(Py_GIL_DISABLED) || defined(Py_NOGIL) #define CYTHON_COMPILING_IN_PYPY 0 #define CYTHON_COMPILING_IN_CPYTHON 0 #define CYTHON_COMPILING_IN_LIMITED_API 0 #define CYTHON_COMPILING_IN_GRAAL 0 #define CYTHON_COMPILING_IN_NOGIL 1 #ifndef CYTHON_USE_TYPE_SLOTS #define CYTHON_USE_TYPE_SLOTS 1 #endif #ifndef CYTHON_USE_TYPE_SPECS #define CYTHON_USE_TYPE_SPECS 0 #endif #undef CYTHON_USE_PYTYPE_LOOKUP #define CYTHON_USE_PYTYPE_LOOKUP 0 #ifndef CYTHON_USE_ASYNC_SLOTS #define CYTHON_USE_ASYNC_SLOTS 1 #endif #ifndef CYTHON_USE_PYLONG_INTERNALS #define CYTHON_USE_PYLONG_INTERNALS 0 #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 #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_GIL #define CYTHON_FAST_GIL 0 #ifndef CYTHON_METH_FASTCALL #define CYTHON_METH_FASTCALL 1 #endif #undef CYTHON_FAST_PYCALL #define CYTHON_FAST_PYCALL 0 #ifndef CYTHON_PEP487_INIT_SUBCLASS #define CYTHON_PEP487_INIT_SUBCLASS 1 #endif #ifndef CYTHON_PEP489_MULTI_PHASE_INIT #define CYTHON_PEP489_MULTI_PHASE_INIT 1 #endif #ifndef CYTHON_USE_MODULE_STATE #define CYTHON_USE_MODULE_STATE 0 #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 #ifndef CYTHON_UPDATE_DESCRIPTOR_DOC #define CYTHON_UPDATE_DESCRIPTOR_DOC 1 #endif #ifndef CYTHON_USE_FREELISTS #define CYTHON_USE_FREELISTS 0 #endif #else #define CYTHON_COMPILING_IN_PYPY 0 #define CYTHON_COMPILING_IN_CPYTHON 1 #define CYTHON_COMPILING_IN_LIMITED_API 0 #define CYTHON_COMPILING_IN_GRAAL 0 #define CYTHON_COMPILING_IN_NOGIL 0 #ifndef CYTHON_USE_TYPE_SLOTS #define CYTHON_USE_TYPE_SLOTS 1 #endif #ifndef CYTHON_USE_TYPE_SPECS #define CYTHON_USE_TYPE_SPECS 0 #endif #ifndef 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 #ifndef 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 #ifndef CYTHON_FAST_THREAD_STATE #define CYTHON_FAST_THREAD_STATE 1 #endif #ifndef CYTHON_FAST_GIL #define CYTHON_FAST_GIL (PY_MAJOR_VERSION < 3 || PY_VERSION_HEX >= 0x03060000 && PY_VERSION_HEX < 0x030C00A6) #endif #ifndef CYTHON_METH_FASTCALL #define CYTHON_METH_FASTCALL (PY_VERSION_HEX >= 0x030700A1) #endif #ifndef CYTHON_FAST_PYCALL #define CYTHON_FAST_PYCALL 1 #endif #ifndef CYTHON_PEP487_INIT_SUBCLASS #define CYTHON_PEP487_INIT_SUBCLASS 1 #endif #if PY_VERSION_HEX < 0x03050000 #undef CYTHON_PEP489_MULTI_PHASE_INIT #define CYTHON_PEP489_MULTI_PHASE_INIT 0 #elif !defined(CYTHON_PEP489_MULTI_PHASE_INIT) #define CYTHON_PEP489_MULTI_PHASE_INIT 1 #endif #ifndef CYTHON_USE_MODULE_STATE #define CYTHON_USE_MODULE_STATE 0 #endif #if PY_VERSION_HEX < 0x030400a1 #undef CYTHON_USE_TP_FINALIZE #define CYTHON_USE_TP_FINALIZE 0 #elif !defined(CYTHON_USE_TP_FINALIZE) #define CYTHON_USE_TP_FINALIZE 1 #endif #if PY_VERSION_HEX < 0x030600B1 #undef CYTHON_USE_DICT_VERSIONS #define CYTHON_USE_DICT_VERSIONS 0 #elif !defined(CYTHON_USE_DICT_VERSIONS) #define CYTHON_USE_DICT_VERSIONS (PY_VERSION_HEX < 0x030C00A5) #endif #if PY_VERSION_HEX < 0x030700A3 #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 1 #endif #ifndef CYTHON_UPDATE_DESCRIPTOR_DOC #define CYTHON_UPDATE_DESCRIPTOR_DOC 1 #endif #ifndef CYTHON_USE_FREELISTS #define CYTHON_USE_FREELISTS 1 #endif #endif #if !defined(CYTHON_FAST_PYCCALL) #define CYTHON_FAST_PYCCALL (CYTHON_FAST_PYCALL && PY_VERSION_HEX >= 0x030600B1) #endif #if !defined(CYTHON_VECTORCALL) #define CYTHON_VECTORCALL (CYTHON_FAST_PYCCALL && PY_VERSION_HEX >= 0x030800B1) #endif #define CYTHON_BACKPORT_VECTORCALL (CYTHON_METH_FASTCALL && PY_VERSION_HEX < 0x030800B1) #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(__cplusplus) /* for clang __has_cpp_attribute(maybe_unused) is true even before C++17 * but leads to warnings with -pedantic, since it is a C++17 feature */ #if ((defined(_MSVC_LANG) && _MSVC_LANG >= 201703L) || __cplusplus >= 201703L) #if __has_cpp_attribute(maybe_unused) #define CYTHON_UNUSED [[maybe_unused]] #endif #endif #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_UNUSED_VAR # if defined(__cplusplus) template void CYTHON_UNUSED_VAR( const T& ) { } # else # define CYTHON_UNUSED_VAR(x) (void)(x) # endif #endif #ifndef CYTHON_MAYBE_UNUSED_VAR #define CYTHON_MAYBE_UNUSED_VAR(x) CYTHON_UNUSED_VAR(x) #endif #ifndef CYTHON_NCP_UNUSED # if CYTHON_COMPILING_IN_CPYTHON # define CYTHON_NCP_UNUSED # else # define CYTHON_NCP_UNUSED CYTHON_UNUSED # endif #endif #ifndef CYTHON_USE_CPP_STD_MOVE #if defined(__cplusplus) && (\ __cplusplus >= 201103L || (defined(_MSC_VER) && _MSC_VER >= 1600)) #define CYTHON_USE_CPP_STD_MOVE 1 #else #define CYTHON_USE_CPP_STD_MOVE 0 #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 short uint16_t; typedef unsigned int uint32_t; #else typedef unsigned __int8 uint8_t; typedef unsigned __int16 uint16_t; typedef unsigned __int32 uint32_t; #endif #endif #if _MSC_VER < 1300 #ifdef _WIN64 typedef unsigned long long __pyx_uintptr_t; #else typedef unsigned int __pyx_uintptr_t; #endif #else #ifdef _WIN64 typedef unsigned __int64 __pyx_uintptr_t; #else typedef unsigned __int32 __pyx_uintptr_t; #endif #endif #else #include typedef uintptr_t __pyx_uintptr_t; #endif #ifndef CYTHON_FALLTHROUGH #if defined(__cplusplus) /* for clang __has_cpp_attribute(fallthrough) is true even before C++17 * but leads to warnings with -pedantic, since it is a C++17 feature */ #if ((defined(_MSVC_LANG) && _MSVC_LANG >= 201703L) || __cplusplus >= 201703L) #if __has_cpp_attribute(fallthrough) #define CYTHON_FALLTHROUGH [[fallthrough]] #endif #endif #ifndef CYTHON_FALLTHROUGH #if __has_cpp_attribute(clang::fallthrough) #define CYTHON_FALLTHROUGH [[clang::fallthrough]] #elif __has_cpp_attribute(gnu::fallthrough) #define CYTHON_FALLTHROUGH [[gnu::fallthrough]] #endif #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 #ifdef __cplusplus template struct __PYX_IS_UNSIGNED_IMPL {static const bool value = T(0) < T(-1);}; #define __PYX_IS_UNSIGNED(type) (__PYX_IS_UNSIGNED_IMPL::value) #else #define __PYX_IS_UNSIGNED(type) (((type)-1) > 0) #endif #if CYTHON_COMPILING_IN_PYPY == 1 #define __PYX_NEED_TP_PRINT_SLOT (PY_VERSION_HEX >= 0x030800b4 && PY_VERSION_HEX < 0x030A0000) #else #define __PYX_NEED_TP_PRINT_SLOT (PY_VERSION_HEX >= 0x030800b4 && PY_VERSION_HEX < 0x03090000) #endif #define __PYX_REINTERPRET_FUNCION(func_pointer, other_pointer) ((func_pointer)(void(*)(void))(other_pointer)) #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 #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_DefaultClassType PyClass_Type #define __Pyx_PyCode_New(a, p, 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) #else #define __Pyx_BUILTIN_MODULE_NAME "builtins" #define __Pyx_DefaultClassType PyType_Type #if CYTHON_COMPILING_IN_LIMITED_API static CYTHON_INLINE PyObject* __Pyx_PyCode_New(int a, int p, 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 *exception_table = NULL; PyObject *types_module=NULL, *code_type=NULL, *result=NULL; #if __PYX_LIMITED_VERSION_HEX < 0x030B0000 PyObject *version_info; PyObject *py_minor_version = NULL; #endif long minor_version = 0; PyObject *type, *value, *traceback; PyErr_Fetch(&type, &value, &traceback); #if __PYX_LIMITED_VERSION_HEX >= 0x030B0000 minor_version = 11; #else if (!(version_info = PySys_GetObject("version_info"))) goto end; if (!(py_minor_version = PySequence_GetItem(version_info, 1))) goto end; minor_version = PyLong_AsLong(py_minor_version); Py_DECREF(py_minor_version); if (minor_version == -1 && PyErr_Occurred()) goto end; #endif if (!(types_module = PyImport_ImportModule("types"))) goto end; if (!(code_type = PyObject_GetAttrString(types_module, "CodeType"))) goto end; if (minor_version <= 7) { (void)p; result = PyObject_CallFunction(code_type, "iiiiiOOOOOOiOO", a, k, l, s, f, code, c, n, v, fn, name, fline, lnos, fv, cell); } else if (minor_version <= 10) { result = PyObject_CallFunction(code_type, "iiiiiiOOOOOOiOO", a,p, k, l, s, f, code, c, n, v, fn, name, fline, lnos, fv, cell); } else { if (!(exception_table = PyBytes_FromStringAndSize(NULL, 0))) goto end; result = PyObject_CallFunction(code_type, "iiiiiiOOOOOOOiOO", a,p, k, l, s, f, code, c, n, v, fn, name, name, fline, lnos, exception_table, fv, cell); } end: Py_XDECREF(code_type); Py_XDECREF(exception_table); Py_XDECREF(types_module); if (type) { PyErr_Restore(type, value, traceback); } return result; } #ifndef CO_OPTIMIZED #define CO_OPTIMIZED 0x0001 #endif #ifndef CO_NEWLOCALS #define CO_NEWLOCALS 0x0002 #endif #ifndef CO_VARARGS #define CO_VARARGS 0x0004 #endif #ifndef CO_VARKEYWORDS #define CO_VARKEYWORDS 0x0008 #endif #ifndef CO_ASYNC_GENERATOR #define CO_ASYNC_GENERATOR 0x0200 #endif #ifndef CO_GENERATOR #define CO_GENERATOR 0x0020 #endif #ifndef CO_COROUTINE #define CO_COROUTINE 0x0080 #endif #elif PY_VERSION_HEX >= 0x030B0000 static CYTHON_INLINE PyCodeObject* __Pyx_PyCode_New(int a, int p, 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) { PyCodeObject *result; PyObject *empty_bytes = PyBytes_FromStringAndSize("", 0); if (!empty_bytes) return NULL; result = #if PY_VERSION_HEX >= 0x030C0000 PyUnstable_Code_NewWithPosOnlyArgs #else PyCode_NewWithPosOnlyArgs #endif (a, p, k, l, s, f, code, c, n, v, fv, cell, fn, name, name, fline, lnos, empty_bytes); Py_DECREF(empty_bytes); return result; } #elif PY_VERSION_HEX >= 0x030800B2 && !CYTHON_COMPILING_IN_PYPY #define __Pyx_PyCode_New(a, p, k, l, s, f, code, c, n, v, fv, cell, fn, name, fline, lnos)\ PyCode_NewWithPosOnlyArgs(a, p, k, l, s, f, code, c, n, v, fv, cell, fn, name, fline, lnos) #else #define __Pyx_PyCode_New(a, p, 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 #endif #if PY_VERSION_HEX >= 0x030900A4 || defined(Py_IS_TYPE) #define __Pyx_IS_TYPE(ob, type) Py_IS_TYPE(ob, type) #else #define __Pyx_IS_TYPE(ob, type) (((const PyObject*)ob)->ob_type == (type)) #endif #if PY_VERSION_HEX >= 0x030A00B1 || defined(Py_Is) #define __Pyx_Py_Is(x, y) Py_Is(x, y) #else #define __Pyx_Py_Is(x, y) ((x) == (y)) #endif #if PY_VERSION_HEX >= 0x030A00B1 || defined(Py_IsNone) #define __Pyx_Py_IsNone(ob) Py_IsNone(ob) #else #define __Pyx_Py_IsNone(ob) __Pyx_Py_Is((ob), Py_None) #endif #if PY_VERSION_HEX >= 0x030A00B1 || defined(Py_IsTrue) #define __Pyx_Py_IsTrue(ob) Py_IsTrue(ob) #else #define __Pyx_Py_IsTrue(ob) __Pyx_Py_Is((ob), Py_True) #endif #if PY_VERSION_HEX >= 0x030A00B1 || defined(Py_IsFalse) #define __Pyx_Py_IsFalse(ob) Py_IsFalse(ob) #else #define __Pyx_Py_IsFalse(ob) __Pyx_Py_Is((ob), Py_False) #endif #define __Pyx_NoneAsNull(obj) (__Pyx_Py_IsNone(obj) ? NULL : (obj)) #if PY_VERSION_HEX >= 0x030900F0 && !CYTHON_COMPILING_IN_PYPY #define __Pyx_PyObject_GC_IsFinalized(o) PyObject_GC_IsFinalized(o) #else #define __Pyx_PyObject_GC_IsFinalized(o) _PyGC_FINALIZED(o) #endif #ifndef CO_COROUTINE #define CO_COROUTINE 0x80 #endif #ifndef CO_ASYNC_GENERATOR #define CO_ASYNC_GENERATOR 0x200 #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 Py_TPFLAGS_SEQUENCE #define Py_TPFLAGS_SEQUENCE 0 #endif #ifndef Py_TPFLAGS_MAPPING #define Py_TPFLAGS_MAPPING 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 #if PY_VERSION_HEX >= 0x030d00A4 # define __Pyx_PyCFunctionFast PyCFunctionFast # define __Pyx_PyCFunctionFastWithKeywords PyCFunctionFastWithKeywords #else # define __Pyx_PyCFunctionFast _PyCFunctionFast # define __Pyx_PyCFunctionFastWithKeywords _PyCFunctionFastWithKeywords #endif #endif #if CYTHON_METH_FASTCALL #define __Pyx_METH_FASTCALL METH_FASTCALL #define __Pyx_PyCFunction_FastCall __Pyx_PyCFunctionFast #define __Pyx_PyCFunction_FastCallWithKeywords __Pyx_PyCFunctionFastWithKeywords #else #define __Pyx_METH_FASTCALL METH_VARARGS #define __Pyx_PyCFunction_FastCall PyCFunction #define __Pyx_PyCFunction_FastCallWithKeywords PyCFunctionWithKeywords #endif #if CYTHON_VECTORCALL #define __pyx_vectorcallfunc vectorcallfunc #define __Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET PY_VECTORCALL_ARGUMENTS_OFFSET #define __Pyx_PyVectorcall_NARGS(n) PyVectorcall_NARGS((size_t)(n)) #elif CYTHON_BACKPORT_VECTORCALL typedef PyObject *(*__pyx_vectorcallfunc)(PyObject *callable, PyObject *const *args, size_t nargsf, PyObject *kwnames); #define __Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET ((size_t)1 << (8 * sizeof(size_t) - 1)) #define __Pyx_PyVectorcall_NARGS(n) ((Py_ssize_t)(((size_t)(n)) & ~__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)) #else #define __Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET 0 #define __Pyx_PyVectorcall_NARGS(n) ((Py_ssize_t)(n)) #endif #if PY_MAJOR_VERSION >= 0x030900B1 #define __Pyx_PyCFunction_CheckExact(func) PyCFunction_CheckExact(func) #else #define __Pyx_PyCFunction_CheckExact(func) PyCFunction_Check(func) #endif #define __Pyx_CyOrPyCFunction_Check(func) PyCFunction_Check(func) #if CYTHON_COMPILING_IN_CPYTHON #define __Pyx_CyOrPyCFunction_GET_FUNCTION(func) (((PyCFunctionObject*)(func))->m_ml->ml_meth) #elif !CYTHON_COMPILING_IN_LIMITED_API #define __Pyx_CyOrPyCFunction_GET_FUNCTION(func) PyCFunction_GET_FUNCTION(func) #endif #if CYTHON_COMPILING_IN_CPYTHON #define __Pyx_CyOrPyCFunction_GET_FLAGS(func) (((PyCFunctionObject*)(func))->m_ml->ml_flags) static CYTHON_INLINE PyObject* __Pyx_CyOrPyCFunction_GET_SELF(PyObject *func) { return (__Pyx_CyOrPyCFunction_GET_FLAGS(func) & METH_STATIC) ? NULL : ((PyCFunctionObject*)func)->m_self; } #endif static CYTHON_INLINE int __Pyx__IsSameCFunction(PyObject *func, void *cfunc) { #if CYTHON_COMPILING_IN_LIMITED_API return PyCFunction_Check(func) && PyCFunction_GetFunction(func) == (PyCFunction) cfunc; #else return PyCFunction_Check(func) && PyCFunction_GET_FUNCTION(func) == (PyCFunction) cfunc; #endif } #define __Pyx_IsSameCFunction(func, cfunc) __Pyx__IsSameCFunction(func, cfunc) #if __PYX_LIMITED_VERSION_HEX < 0x030900B1 #define __Pyx_PyType_FromModuleAndSpec(m, s, b) ((void)m, PyType_FromSpecWithBases(s, b)) typedef PyObject *(*__Pyx_PyCMethod)(PyObject *, PyTypeObject *, PyObject *const *, size_t, PyObject *); #else #define __Pyx_PyType_FromModuleAndSpec(m, s, b) PyType_FromModuleAndSpec(m, s, b) #define __Pyx_PyCMethod PyCMethod #endif #ifndef METH_METHOD #define METH_METHOD 0x200 #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_LIMITED_API #define __Pyx_PyCode_HasFreeVars(co) (PyCode_GetNumFree(co) > 0) #define __Pyx_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_COMPILING_IN_LIMITED_API #define __Pyx_PyThreadState_Current PyThreadState_Get() #elif !CYTHON_FAST_THREAD_STATE #define __Pyx_PyThreadState_Current PyThreadState_GET() #elif PY_VERSION_HEX >= 0x030d00A1 #define __Pyx_PyThreadState_Current PyThreadState_GetUnchecked() #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 CYTHON_COMPILING_IN_LIMITED_API static CYTHON_INLINE void *__Pyx_PyModule_GetState(PyObject *op) { void *result; result = PyModule_GetState(op); if (!result) Py_FatalError("Couldn't find the module state"); return result; } #endif #define __Pyx_PyObject_GetSlot(obj, name, func_ctype) __Pyx_PyType_GetSlot(Py_TYPE(obj), name, func_ctype) #if CYTHON_COMPILING_IN_LIMITED_API #define __Pyx_PyType_GetSlot(type, name, func_ctype) ((func_ctype) PyType_GetSlot((type), Py_##name)) #else #define __Pyx_PyType_GetSlot(type, name, func_ctype) ((type)->name) #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 PY_MAJOR_VERSION < 3 #if CYTHON_COMPILING_IN_PYPY #if PYPY_VERSION_NUM < 0x07030600 #if defined(__cplusplus) && __cplusplus >= 201402L [[deprecated("`with nogil:` inside a nogil function will not release the GIL in PyPy2 < 7.3.6")]] #elif defined(__GNUC__) || defined(__clang__) __attribute__ ((__deprecated__("`with nogil:` inside a nogil function will not release the GIL in PyPy2 < 7.3.6"))) #elif defined(_MSC_VER) __declspec(deprecated("`with nogil:` inside a nogil function will not release the GIL in PyPy2 < 7.3.6")) #endif static CYTHON_INLINE int PyGILState_Check(void) { return 0; } #else // PYPY_VERSION_NUM < 0x07030600 #endif // PYPY_VERSION_NUM < 0x07030600 #else static CYTHON_INLINE int PyGILState_Check(void) { PyThreadState * tstate = _PyThreadState_Current; return tstate && (tstate == PyGILState_GetThisThreadState()); } #endif #endif #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX < 0x030d0000 || 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 > 0x030600B4 && PY_VERSION_HEX < 0x030d0000 && CYTHON_USE_UNICODE_INTERNALS #define __Pyx_PyDict_GetItemStrWithError(dict, name) _PyDict_GetItem_KnownHash(dict, name, ((PyASCIIObject *) name)->hash) static CYTHON_INLINE PyObject * __Pyx_PyDict_GetItemStr(PyObject *dict, PyObject *name) { PyObject *res = __Pyx_PyDict_GetItemStrWithError(dict, name); if (res == NULL) PyErr_Clear(); return res; } #elif PY_MAJOR_VERSION >= 3 && (!CYTHON_COMPILING_IN_PYPY || PYPY_VERSION_NUM >= 0x07020000) #define __Pyx_PyDict_GetItemStrWithError PyDict_GetItemWithError #define __Pyx_PyDict_GetItemStr PyDict_GetItem #else static CYTHON_INLINE PyObject * __Pyx_PyDict_GetItemStrWithError(PyObject *dict, PyObject *name) { #if CYTHON_COMPILING_IN_PYPY return PyDict_GetItem(dict, name); #else PyDictEntry *ep; PyDictObject *mp = (PyDictObject*) dict; long hash = ((PyStringObject *) name)->ob_shash; assert(hash != -1); ep = (mp->ma_lookup)(mp, name, hash); if (ep == NULL) { return NULL; } return ep->me_value; #endif } #define __Pyx_PyDict_GetItemStr PyDict_GetItem #endif #if CYTHON_USE_TYPE_SLOTS #define __Pyx_PyType_GetFlags(tp) (((PyTypeObject *)tp)->tp_flags) #define __Pyx_PyType_HasFeature(type, feature) ((__Pyx_PyType_GetFlags(type) & (feature)) != 0) #define __Pyx_PyObject_GetIterNextFunc(obj) (Py_TYPE(obj)->tp_iternext) #else #define __Pyx_PyType_GetFlags(tp) (PyType_GetFlags((PyTypeObject *)tp)) #define __Pyx_PyType_HasFeature(type, feature) PyType_HasFeature(type, feature) #define __Pyx_PyObject_GetIterNextFunc(obj) PyIter_Next #endif #if CYTHON_COMPILING_IN_LIMITED_API #define __Pyx_SetItemOnTypeDict(tp, k, v) PyObject_GenericSetAttr((PyObject*)tp, k, v) #else #define __Pyx_SetItemOnTypeDict(tp, k, v) PyDict_SetItem(tp->tp_dict, k, v) #endif #if CYTHON_USE_TYPE_SPECS && PY_VERSION_HEX >= 0x03080000 #define __Pyx_PyHeapTypeObject_GC_Del(obj) {\ PyTypeObject *type = Py_TYPE((PyObject*)obj);\ assert(__Pyx_PyType_HasFeature(type, Py_TPFLAGS_HEAPTYPE));\ PyObject_GC_Del(obj);\ Py_DECREF(type);\ } #else #define __Pyx_PyHeapTypeObject_GC_Del(obj) PyObject_GC_Del(obj) #endif #if CYTHON_COMPILING_IN_LIMITED_API #define CYTHON_PEP393_ENABLED 1 #define __Pyx_PyUnicode_READY(op) (0) #define __Pyx_PyUnicode_GET_LENGTH(u) PyUnicode_GetLength(u) #define __Pyx_PyUnicode_READ_CHAR(u, i) PyUnicode_ReadChar(u, i) #define __Pyx_PyUnicode_MAX_CHAR_VALUE(u) ((void)u, 1114111U) #define __Pyx_PyUnicode_KIND(u) ((void)u, (0)) #define __Pyx_PyUnicode_DATA(u) ((void*)u) #define __Pyx_PyUnicode_READ(k, d, i) ((void)k, PyUnicode_ReadChar((PyObject*)(d), i)) #define __Pyx_PyUnicode_IS_TRUE(u) (0 != PyUnicode_GetLength(u)) #elif PY_VERSION_HEX > 0x03030000 && defined(PyUnicode_KIND) #define CYTHON_PEP393_ENABLED 1 #if PY_VERSION_HEX >= 0x030C0000 #define __Pyx_PyUnicode_READY(op) (0) #else #define __Pyx_PyUnicode_READY(op) (likely(PyUnicode_IS_READY(op)) ?\ 0 : _PyUnicode_Ready((PyObject *)(op))) #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) ((int)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, (Py_UCS4) ch) #if PY_VERSION_HEX >= 0x030C0000 #define __Pyx_PyUnicode_IS_TRUE(u) (0 != PyUnicode_GET_LENGTH(u)) #else #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 #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) ? 65535U : 1114111U) #define __Pyx_PyUnicode_KIND(u) ((int)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] = (Py_UNICODE) 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 #if !defined(PyUnicode_DecodeUnicodeEscape) #define PyUnicode_DecodeUnicodeEscape(s, size, errors) PyUnicode_Decode(s, size, "unicode_escape", errors) #endif #if !defined(PyUnicode_Contains) || (PY_MAJOR_VERSION == 2 && PYPY_VERSION_NUM < 0x07030500) #undef PyUnicode_Contains #define PyUnicode_Contains(u, s) PySequence_Contains(u, s) #endif #if !defined(PyByteArray_Check) #define PyByteArray_Check(obj) PyObject_TypeCheck(obj, &PyByteArray_Type) #endif #if !defined(PyObject_Format) #define PyObject_Format(obj, fmt) PyObject_CallMethod(obj, "__format__", "O", fmt) #endif #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 #if CYTHON_COMPILING_IN_CPYTHON #define __Pyx_PySequence_ListKeepNew(obj)\ (likely(PyList_CheckExact(obj) && Py_REFCNT(obj) == 1) ? __Pyx_NewRef(obj) : PySequence_List(obj)) #else #define __Pyx_PySequence_ListKeepNew(obj) PySequence_List(obj) #endif #ifndef PySet_CheckExact #define PySet_CheckExact(obj) __Pyx_IS_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_ITEM(o, i) PySequence_ITEM(o, i) #define __Pyx_PySequence_SIZE(seq) Py_SIZE(seq) #define __Pyx_PyTuple_SET_ITEM(o, i, v) (PyTuple_SET_ITEM(o, i, v), (0)) #define __Pyx_PyList_SET_ITEM(o, i, v) (PyList_SET_ITEM(o, i, v), (0)) #define __Pyx_PyTuple_GET_SIZE(o) PyTuple_GET_SIZE(o) #define __Pyx_PyList_GET_SIZE(o) PyList_GET_SIZE(o) #define __Pyx_PySet_GET_SIZE(o) PySet_GET_SIZE(o) #define __Pyx_PyBytes_GET_SIZE(o) PyBytes_GET_SIZE(o) #define __Pyx_PyByteArray_GET_SIZE(o) PyByteArray_GET_SIZE(o) #else #define __Pyx_PySequence_ITEM(o, i) PySequence_GetItem(o, i) #define __Pyx_PySequence_SIZE(seq) PySequence_Size(seq) #define __Pyx_PyTuple_SET_ITEM(o, i, v) PyTuple_SetItem(o, i, v) #define __Pyx_PyList_SET_ITEM(o, i, v) PyList_SetItem(o, i, v) #define __Pyx_PyTuple_GET_SIZE(o) PyTuple_Size(o) #define __Pyx_PyList_GET_SIZE(o) PyList_Size(o) #define __Pyx_PySet_GET_SIZE(o) PySet_Size(o) #define __Pyx_PyBytes_GET_SIZE(o) PyBytes_Size(o) #define __Pyx_PyByteArray_GET_SIZE(o) PyByteArray_Size(o) #endif #if __PYX_LIMITED_VERSION_HEX >= 0x030d00A1 #define __Pyx_PyImport_AddModuleRef(name) PyImport_AddModuleRef(name) #else static CYTHON_INLINE PyObject *__Pyx_PyImport_AddModuleRef(const char *name) { PyObject *module = PyImport_AddModule(name); Py_XINCREF(module); return module; } #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 __Pyx_Py3Int_Check(op) PyLong_Check(op) #define __Pyx_Py3Int_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 #else #define __Pyx_Py3Int_Check(op) (PyLong_Check(op) || PyInt_Check(op)) #define __Pyx_Py3Int_CheckExact(op) (PyLong_CheckExact(op) || PyInt_CheckExact(op)) #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 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; } #ifdef CYTHON_EXTERN_C #undef __PYX_EXTERN_C #define __PYX_EXTERN_C CYTHON_EXTERN_C #elif defined(__PYX_EXTERN_C) #ifdef _MSC_VER #pragma message ("Please do not define the '__PYX_EXTERN_C' macro externally. Use 'CYTHON_EXTERN_C' instead.") #else #warning Please do not define the '__PYX_EXTERN_C' macro externally. Use 'CYTHON_EXTERN_C' instead. #endif #else #ifdef __cplusplus #define __PYX_EXTERN_C extern "C" #else #define __PYX_EXTERN_C extern #endif #endif #define __PYX_HAVE__astroscrappy__astroscrappy #define __PYX_HAVE_API__astroscrappy__astroscrappy /* Early includes */ #include #include /* Using NumPy API declarations from "numpy/__init__.cython-30.pxd" */ #include "numpy/arrayobject.h" #include "numpy/ndarrayobject.h" #include "numpy/ndarraytypes.h" #include "numpy/arrayscalars.h" #include "numpy/ufuncobject.h" #include #include #include "pythread.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 Py_ssize_t __Pyx_ssize_strlen(const char *s); static CYTHON_INLINE const char* __Pyx_PyObject_AsString(PyObject*); static CYTHON_INLINE const char* __Pyx_PyObject_AsStringAndSize(PyObject*, Py_ssize_t* length); static CYTHON_INLINE PyObject* __Pyx_PyByteArray_FromString(const char*); #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_uintptr_t) __Pyx_PyObject_AsString(s)) #define __Pyx_PyObject_AsWritableSString(s) ((signed char*)(__pyx_uintptr_t) __Pyx_PyObject_AsString(s)) #define __Pyx_PyObject_AsWritableUString(s) ((unsigned char*)(__pyx_uintptr_t) __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) #define __Pyx_PyUnicode_FromOrdinal(o) PyUnicode_FromOrdinal((int)o) #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 #if CYTHON_USE_PYLONG_INTERNALS #if PY_VERSION_HEX >= 0x030C00A7 #ifndef _PyLong_SIGN_MASK #define _PyLong_SIGN_MASK 3 #endif #ifndef _PyLong_NON_SIZE_BITS #define _PyLong_NON_SIZE_BITS 3 #endif #define __Pyx_PyLong_Sign(x) (((PyLongObject*)x)->long_value.lv_tag & _PyLong_SIGN_MASK) #define __Pyx_PyLong_IsNeg(x) ((__Pyx_PyLong_Sign(x) & 2) != 0) #define __Pyx_PyLong_IsNonNeg(x) (!__Pyx_PyLong_IsNeg(x)) #define __Pyx_PyLong_IsZero(x) (__Pyx_PyLong_Sign(x) & 1) #define __Pyx_PyLong_IsPos(x) (__Pyx_PyLong_Sign(x) == 0) #define __Pyx_PyLong_CompactValueUnsigned(x) (__Pyx_PyLong_Digits(x)[0]) #define __Pyx_PyLong_DigitCount(x) ((Py_ssize_t) (((PyLongObject*)x)->long_value.lv_tag >> _PyLong_NON_SIZE_BITS)) #define __Pyx_PyLong_SignedDigitCount(x)\ ((1 - (Py_ssize_t) __Pyx_PyLong_Sign(x)) * __Pyx_PyLong_DigitCount(x)) #if defined(PyUnstable_Long_IsCompact) && defined(PyUnstable_Long_CompactValue) #define __Pyx_PyLong_IsCompact(x) PyUnstable_Long_IsCompact((PyLongObject*) x) #define __Pyx_PyLong_CompactValue(x) PyUnstable_Long_CompactValue((PyLongObject*) x) #else #define __Pyx_PyLong_IsCompact(x) (((PyLongObject*)x)->long_value.lv_tag < (2 << _PyLong_NON_SIZE_BITS)) #define __Pyx_PyLong_CompactValue(x) ((1 - (Py_ssize_t) __Pyx_PyLong_Sign(x)) * (Py_ssize_t) __Pyx_PyLong_Digits(x)[0]) #endif typedef Py_ssize_t __Pyx_compact_pylong; typedef size_t __Pyx_compact_upylong; #else #define __Pyx_PyLong_IsNeg(x) (Py_SIZE(x) < 0) #define __Pyx_PyLong_IsNonNeg(x) (Py_SIZE(x) >= 0) #define __Pyx_PyLong_IsZero(x) (Py_SIZE(x) == 0) #define __Pyx_PyLong_IsPos(x) (Py_SIZE(x) > 0) #define __Pyx_PyLong_CompactValueUnsigned(x) ((Py_SIZE(x) == 0) ? 0 : __Pyx_PyLong_Digits(x)[0]) #define __Pyx_PyLong_DigitCount(x) __Pyx_sst_abs(Py_SIZE(x)) #define __Pyx_PyLong_SignedDigitCount(x) Py_SIZE(x) #define __Pyx_PyLong_IsCompact(x) (Py_SIZE(x) == 0 || Py_SIZE(x) == 1 || Py_SIZE(x) == -1) #define __Pyx_PyLong_CompactValue(x)\ ((Py_SIZE(x) == 0) ? (sdigit) 0 : ((Py_SIZE(x) < 0) ? -(sdigit)__Pyx_PyLong_Digits(x)[0] : (sdigit)__Pyx_PyLong_Digits(x)[0])) typedef sdigit __Pyx_compact_pylong; typedef digit __Pyx_compact_upylong; #endif #if PY_VERSION_HEX >= 0x030C00A5 #define __Pyx_PyLong_Digits(x) (((PyLongObject*)x)->long_value.ob_digit) #else #define __Pyx_PyLong_Digits(x) (((PyLongObject*)x)->ob_digit) #endif #endif #if PY_MAJOR_VERSION < 3 && __PYX_DEFAULT_STRING_ENCODING_IS_ASCII #include 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] = (char) 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 #include 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; } #if !CYTHON_USE_MODULE_STATE static PyObject *__pyx_m = NULL; #endif 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) && !defined(_MSC_VER)) || ((defined (__STDC_VERSION__) && __STDC_VERSION__ >= 201112L) && !defined(__STDC_NO_COMPLEX__) && !defined(_MSC_VER)) #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 /* #### Code section: filename_table ### */ static const char *__pyx_f[] = { "astroscrappy/astroscrappy.pyx", "", "__init__.cython-30.pxd", "type.pxd", }; /* #### Code section: utility_code_proto_before_types ### */ /* ForceInitThreads.proto */ #ifndef __PYX_FORCE_INIT_THREADS #define __PYX_FORCE_INIT_THREADS 0 #endif /* 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() /* BufferFormatStructs.proto */ 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; /* Atomics.proto */ #include #ifndef CYTHON_ATOMICS #define CYTHON_ATOMICS 1 #endif #define __PYX_CYTHON_ATOMICS_ENABLED() CYTHON_ATOMICS #define __pyx_atomic_int_type int #define __pyx_nonatomic_int_type int #if CYTHON_ATOMICS && (defined(__STDC_VERSION__) &&\ (__STDC_VERSION__ >= 201112L) &&\ !defined(__STDC_NO_ATOMICS__)) #include #elif CYTHON_ATOMICS && (defined(__cplusplus) && (\ (__cplusplus >= 201103L) ||\ (defined(_MSC_VER) && _MSC_VER >= 1700))) #include #endif #if CYTHON_ATOMICS && (defined(__STDC_VERSION__) &&\ (__STDC_VERSION__ >= 201112L) &&\ !defined(__STDC_NO_ATOMICS__) &&\ ATOMIC_INT_LOCK_FREE == 2) #undef __pyx_atomic_int_type #define __pyx_atomic_int_type atomic_int #define __pyx_atomic_incr_aligned(value) atomic_fetch_add_explicit(value, 1, memory_order_relaxed) #define __pyx_atomic_decr_aligned(value) atomic_fetch_sub_explicit(value, 1, memory_order_acq_rel) #if defined(__PYX_DEBUG_ATOMICS) && defined(_MSC_VER) #pragma message ("Using standard C atomics") #elif defined(__PYX_DEBUG_ATOMICS) #warning "Using standard C atomics" #endif #elif CYTHON_ATOMICS && (defined(__cplusplus) && (\ (__cplusplus >= 201103L) ||\ \ (defined(_MSC_VER) && _MSC_VER >= 1700)) &&\ ATOMIC_INT_LOCK_FREE == 2) #undef __pyx_atomic_int_type #define __pyx_atomic_int_type std::atomic_int #define __pyx_atomic_incr_aligned(value) std::atomic_fetch_add_explicit(value, 1, std::memory_order_relaxed) #define __pyx_atomic_decr_aligned(value) std::atomic_fetch_sub_explicit(value, 1, std::memory_order_acq_rel) #if defined(__PYX_DEBUG_ATOMICS) && defined(_MSC_VER) #pragma message ("Using standard C++ atomics") #elif defined(__PYX_DEBUG_ATOMICS) #warning "Using standard C++ atomics" #endif #elif 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) #include #undef __pyx_atomic_int_type #define __pyx_atomic_int_type long #undef __pyx_nonatomic_int_type #define __pyx_nonatomic_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 #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 /* 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]) /* #### Code section: numeric_typedefs ### */ /* "../../../../../tmp/build-env-2vlxkjf_/lib/python3.12/site-packages/numpy/__init__.cython-30.pxd":770 * # 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/build-env-2vlxkjf_/lib/python3.12/site-packages/numpy/__init__.cython-30.pxd":771 * * 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/build-env-2vlxkjf_/lib/python3.12/site-packages/numpy/__init__.cython-30.pxd":772 * 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/build-env-2vlxkjf_/lib/python3.12/site-packages/numpy/__init__.cython-30.pxd":773 * 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/build-env-2vlxkjf_/lib/python3.12/site-packages/numpy/__init__.cython-30.pxd":777 * #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/build-env-2vlxkjf_/lib/python3.12/site-packages/numpy/__init__.cython-30.pxd":778 * * 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/build-env-2vlxkjf_/lib/python3.12/site-packages/numpy/__init__.cython-30.pxd":779 * 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/build-env-2vlxkjf_/lib/python3.12/site-packages/numpy/__init__.cython-30.pxd":780 * 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/build-env-2vlxkjf_/lib/python3.12/site-packages/numpy/__init__.cython-30.pxd":784 * #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/build-env-2vlxkjf_/lib/python3.12/site-packages/numpy/__init__.cython-30.pxd":785 * * 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/build-env-2vlxkjf_/lib/python3.12/site-packages/numpy/__init__.cython-30.pxd":792 * ctypedef double complex complex128_t * * ctypedef npy_longlong longlong_t # <<<<<<<<<<<<<< * ctypedef npy_ulonglong ulonglong_t * */ typedef npy_longlong __pyx_t_5numpy_longlong_t; /* "../../../../../tmp/build-env-2vlxkjf_/lib/python3.12/site-packages/numpy/__init__.cython-30.pxd":793 * * ctypedef npy_longlong longlong_t * ctypedef npy_ulonglong ulonglong_t # <<<<<<<<<<<<<< * * ctypedef npy_intp intp_t */ typedef npy_ulonglong __pyx_t_5numpy_ulonglong_t; /* "../../../../../tmp/build-env-2vlxkjf_/lib/python3.12/site-packages/numpy/__init__.cython-30.pxd":795 * ctypedef npy_ulonglong ulonglong_t * * ctypedef npy_intp intp_t # <<<<<<<<<<<<<< * ctypedef npy_uintp uintp_t * */ typedef npy_intp __pyx_t_5numpy_intp_t; /* "../../../../../tmp/build-env-2vlxkjf_/lib/python3.12/site-packages/numpy/__init__.cython-30.pxd":796 * * ctypedef npy_intp intp_t * ctypedef npy_uintp uintp_t # <<<<<<<<<<<<<< * * ctypedef npy_double float_t */ typedef npy_uintp __pyx_t_5numpy_uintp_t; /* "../../../../../tmp/build-env-2vlxkjf_/lib/python3.12/site-packages/numpy/__init__.cython-30.pxd":798 * 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/build-env-2vlxkjf_/lib/python3.12/site-packages/numpy/__init__.cython-30.pxd":799 * * ctypedef npy_double float_t * ctypedef npy_double double_t # <<<<<<<<<<<<<< * ctypedef npy_longdouble longdouble_t * */ typedef npy_double __pyx_t_5numpy_double_t; /* "../../../../../tmp/build-env-2vlxkjf_/lib/python3.12/site-packages/numpy/__init__.cython-30.pxd":800 * ctypedef npy_double float_t * ctypedef npy_double double_t * ctypedef npy_longdouble longdouble_t # <<<<<<<<<<<<<< * * ctypedef float complex cfloat_t */ typedef npy_longdouble __pyx_t_5numpy_longdouble_t; /* "astroscrappy/astroscrappy.pyx":22 * from libc.stdint cimport uint8_t * * ctypedef uint8_t bool # <<<<<<<<<<<<<< * * from libc.stdlib cimport malloc, free */ typedef uint8_t __pyx_t_12astroscrappy_12astroscrappy_bool; /* #### Code section: complex_type_declarations ### */ /* Declarations.proto */ #if CYTHON_CCOMPLEX && (1) && (!0 || __cplusplus) #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 && (1) && (!0 || __cplusplus) #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); /* Declarations.proto */ #if CYTHON_CCOMPLEX && (1) && (!0 || __cplusplus) #ifdef __cplusplus typedef ::std::complex< long double > __pyx_t_long_double_complex; #else typedef long double _Complex __pyx_t_long_double_complex; #endif #else typedef struct { long double real, imag; } __pyx_t_long_double_complex; #endif static CYTHON_INLINE __pyx_t_long_double_complex __pyx_t_long_double_complex_from_parts(long double, long double); /* #### Code section: type_declarations ### */ /*--- Type declarations ---*/ struct __pyx_array_obj; struct __pyx_MemviewEnum_obj; struct __pyx_memoryview_obj; struct __pyx_memoryviewslice_obj; /* "../../../../../tmp/build-env-2vlxkjf_/lib/python3.12/site-packages/numpy/__init__.cython-30.pxd":1096 * * # Iterator API added in v1.6 * ctypedef int (*NpyIter_IterNextFunc)(NpyIter* it) noexcept nogil # <<<<<<<<<<<<<< * ctypedef void (*NpyIter_GetMultiIndexFunc)(NpyIter* it, npy_intp* outcoords) noexcept nogil * */ typedef int (*__pyx_t_5numpy_NpyIter_IterNextFunc)(NpyIter *); /* "../../../../../tmp/build-env-2vlxkjf_/lib/python3.12/site-packages/numpy/__init__.cython-30.pxd":1097 * # Iterator API added in v1.6 * ctypedef int (*NpyIter_IterNextFunc)(NpyIter* it) noexcept nogil * ctypedef void (*NpyIter_GetMultiIndexFunc)(NpyIter* it, npy_intp* outcoords) noexcept nogil # <<<<<<<<<<<<<< * * cdef extern from "numpy/arrayobject.h": */ typedef void (*__pyx_t_5numpy_NpyIter_GetMultiIndexFunc)(NpyIter *, npy_intp *); /* "View.MemoryView":114 * @cython.collection_type("sequence") * @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":302 * * @cname('__pyx_MemviewEnum') * cdef class Enum(object): # <<<<<<<<<<<<<< * cdef object name * def __init__(self, name): */ struct __pyx_MemviewEnum_obj { PyObject_HEAD PyObject *name; }; /* "View.MemoryView":337 * * @cname('__pyx_memoryview') * cdef class memoryview: # <<<<<<<<<<<<<< * * 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_type acquisition_count; Py_buffer view; int flags; int dtype_is_object; __Pyx_TypeInfo *typeinfo; }; /* "View.MemoryView":952 * @cython.collection_type("sequence") * @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":114 * @cython.collection_type("sequence") * @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":337 * * @cname('__pyx_memoryview') * cdef class memoryview: # <<<<<<<<<<<<<< * * 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 *); PyObject *(*_get_base)(struct __pyx_memoryview_obj *); }; static struct __pyx_vtabstruct_memoryview *__pyx_vtabptr_memoryview; /* "View.MemoryView":952 * @cython.collection_type("sequence") * @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; /* #### Code section: utility_code_proto ### */ /* --- Runtime support code (head) --- */ /* Refnanny.proto */ #ifndef CYTHON_REFNANNY #define CYTHON_REFNANNY 0 #endif #if CYTHON_REFNANNY typedef struct { void (*INCREF)(void*, PyObject*, Py_ssize_t); void (*DECREF)(void*, PyObject*, Py_ssize_t); void (*GOTREF)(void*, PyObject*, Py_ssize_t); void (*GIVEREF)(void*, PyObject*, Py_ssize_t); void* (*SetupContext)(const char*, Py_ssize_t, 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__));\ } #define __Pyx_RefNannyFinishContextNogil() {\ PyGILState_STATE __pyx_gilstate_save = PyGILState_Ensure();\ __Pyx_RefNannyFinishContext();\ PyGILState_Release(__pyx_gilstate_save);\ } #else #define __Pyx_RefNannySetupContext(name, acquire_gil)\ __pyx_refnanny = __Pyx_RefNanny->SetupContext((name), (__LINE__), (__FILE__)) #define __Pyx_RefNannyFinishContextNogil() __Pyx_RefNannyFinishContext() #endif #define __Pyx_RefNannyFinishContextNogil() {\ PyGILState_STATE __pyx_gilstate_save = PyGILState_Ensure();\ __Pyx_RefNannyFinishContext();\ PyGILState_Release(__pyx_gilstate_save);\ } #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); else {__Pyx_INCREF(r); }} while(0) #define __Pyx_XDECREF(r) do { if((r) == NULL); else {__Pyx_DECREF(r); }} while(0) #define __Pyx_XGOTREF(r) do { if((r) == NULL); else {__Pyx_GOTREF(r); }} while(0) #define __Pyx_XGIVEREF(r) do { if((r) == NULL); else {__Pyx_GIVEREF(r);}} while(0) #else #define __Pyx_RefNannyDeclarations #define __Pyx_RefNannySetupContext(name, acquire_gil) #define __Pyx_RefNannyFinishContextNogil() #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_Py_XDECREF_SET(r, v) do {\ PyObject *tmp = (PyObject *) r;\ r = v; Py_XDECREF(tmp);\ } while (0) #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) /* 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 /* PyThreadStateGet.proto */ #if CYTHON_FAST_THREAD_STATE #define __Pyx_PyThreadState_declare PyThreadState *__pyx_tstate; #define __Pyx_PyThreadState_assign __pyx_tstate = __Pyx_PyThreadState_Current; #if PY_VERSION_HEX >= 0x030C00A6 #define __Pyx_PyErr_Occurred() (__pyx_tstate->current_exception != NULL) #define __Pyx_PyErr_CurrentExceptionType() (__pyx_tstate->current_exception ? (PyObject*) Py_TYPE(__pyx_tstate->current_exception) : (PyObject*) NULL) #else #define __Pyx_PyErr_Occurred() (__pyx_tstate->curexc_type != NULL) #define __Pyx_PyErr_CurrentExceptionType() (__pyx_tstate->curexc_type) #endif #else #define __Pyx_PyThreadState_declare #define __Pyx_PyThreadState_assign #define __Pyx_PyErr_Occurred() (PyErr_Occurred() != NULL) #define __Pyx_PyErr_CurrentExceptionType() 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 && PY_VERSION_HEX < 0x030C00A6 #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 /* 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 /* PyObjectGetAttrStrNoError.proto */ static CYTHON_INLINE PyObject* __Pyx_PyObject_GetAttrStrNoError(PyObject* obj, PyObject* attr_name); /* GetBuiltinName.proto */ static PyObject *__Pyx_GetBuiltinName(PyObject *name); /* TupleAndListFromArray.proto */ #if CYTHON_COMPILING_IN_CPYTHON static CYTHON_INLINE PyObject* __Pyx_PyList_FromArray(PyObject *const *src, Py_ssize_t n); static CYTHON_INLINE PyObject* __Pyx_PyTuple_FromArray(PyObject *const *src, Py_ssize_t n); #endif /* 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); /* fastcall.proto */ #if CYTHON_AVOID_BORROWED_REFS #define __Pyx_Arg_VARARGS(args, i) PySequence_GetItem(args, i) #elif CYTHON_ASSUME_SAFE_MACROS #define __Pyx_Arg_VARARGS(args, i) PyTuple_GET_ITEM(args, i) #else #define __Pyx_Arg_VARARGS(args, i) PyTuple_GetItem(args, i) #endif #if CYTHON_AVOID_BORROWED_REFS #define __Pyx_Arg_NewRef_VARARGS(arg) __Pyx_NewRef(arg) #define __Pyx_Arg_XDECREF_VARARGS(arg) Py_XDECREF(arg) #else #define __Pyx_Arg_NewRef_VARARGS(arg) arg #define __Pyx_Arg_XDECREF_VARARGS(arg) #endif #define __Pyx_NumKwargs_VARARGS(kwds) PyDict_Size(kwds) #define __Pyx_KwValues_VARARGS(args, nargs) NULL #define __Pyx_GetKwValue_VARARGS(kw, kwvalues, s) __Pyx_PyDict_GetItemStrWithError(kw, s) #define __Pyx_KwargsAsDict_VARARGS(kw, kwvalues) PyDict_Copy(kw) #if CYTHON_METH_FASTCALL #define __Pyx_Arg_FASTCALL(args, i) args[i] #define __Pyx_NumKwargs_FASTCALL(kwds) PyTuple_GET_SIZE(kwds) #define __Pyx_KwValues_FASTCALL(args, nargs) ((args) + (nargs)) static CYTHON_INLINE PyObject * __Pyx_GetKwValue_FASTCALL(PyObject *kwnames, PyObject *const *kwvalues, PyObject *s); #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030d0000 CYTHON_UNUSED static PyObject *__Pyx_KwargsAsDict_FASTCALL(PyObject *kwnames, PyObject *const *kwvalues); #else #define __Pyx_KwargsAsDict_FASTCALL(kw, kwvalues) _PyStack_AsDict(kwvalues, kw) #endif #define __Pyx_Arg_NewRef_FASTCALL(arg) arg /* no-op, __Pyx_Arg_FASTCALL is direct and this needs to have the same reference counting */ #define __Pyx_Arg_XDECREF_FASTCALL(arg) #else #define __Pyx_Arg_FASTCALL __Pyx_Arg_VARARGS #define __Pyx_NumKwargs_FASTCALL __Pyx_NumKwargs_VARARGS #define __Pyx_KwValues_FASTCALL __Pyx_KwValues_VARARGS #define __Pyx_GetKwValue_FASTCALL __Pyx_GetKwValue_VARARGS #define __Pyx_KwargsAsDict_FASTCALL __Pyx_KwargsAsDict_VARARGS #define __Pyx_Arg_NewRef_FASTCALL(arg) __Pyx_Arg_NewRef_VARARGS(arg) #define __Pyx_Arg_XDECREF_FASTCALL(arg) __Pyx_Arg_XDECREF_VARARGS(arg) #endif #if CYTHON_COMPILING_IN_CPYTHON && CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS #define __Pyx_ArgsSlice_VARARGS(args, start, stop) __Pyx_PyTuple_FromArray(&__Pyx_Arg_VARARGS(args, start), stop - start) #define __Pyx_ArgsSlice_FASTCALL(args, start, stop) __Pyx_PyTuple_FromArray(&__Pyx_Arg_FASTCALL(args, start), stop - start) #else #define __Pyx_ArgsSlice_VARARGS(args, start, stop) PyTuple_GetSlice(args, start, stop) #define __Pyx_ArgsSlice_FASTCALL(args, start, stop) PyTuple_GetSlice(args, start, stop) #endif /* 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 *const *kwvalues, 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(__Pyx_IS_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); /* RaiseException.proto */ static void __Pyx_Raise(PyObject *type, PyObject *value, PyObject *tb, PyObject *cause); /* PyFunctionFastCall.proto */ #if CYTHON_FAST_PYCALL #if !CYTHON_VECTORCALL #define __Pyx_PyFunction_FastCall(func, args, nargs)\ __Pyx_PyFunction_FastCallDict((func), (args), (nargs), NULL) static PyObject *__Pyx_PyFunction_FastCallDict(PyObject *func, PyObject **args, Py_ssize_t nargs, PyObject *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_VECTORCALL #if PY_VERSION_HEX >= 0x03080000 #include "frameobject.h" #if PY_VERSION_HEX >= 0x030b00a6 && !CYTHON_COMPILING_IN_LIMITED_API #ifndef Py_BUILD_CORE #define Py_BUILD_CORE 1 #endif #include "internal/pycore_frame.h" #endif #define __Pxy_PyFrame_Initialize_Offsets() #define __Pyx_PyFrame_GetLocalsplus(frame) ((frame)->f_localsplus) #else static size_t __pyx_pyframe_localsplus_offset = 0; #include "frameobject.h" #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 #endif #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 /* PyObjectFastCall.proto */ #define __Pyx_PyObject_FastCall(func, args, nargs) __Pyx_PyObject_FastCallDict(func, args, (size_t)(nargs), NULL) static CYTHON_INLINE PyObject* __Pyx_PyObject_FastCallDict(PyObject *func, PyObject **args, size_t nargs, PyObject *kwargs); /* RaiseUnexpectedTypeError.proto */ static int __Pyx_RaiseUnexpectedTypeError(const char *expected, PyObject *obj); /* GCCDiagnostics.proto */ #if !defined(__INTEL_COMPILER) && defined(__GNUC__) && (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 6)) #define __Pyx_HAS_GCC_DIAGNOSTIC #endif /* BuildPyUnicode.proto */ static PyObject* __Pyx_PyUnicode_BuildFromAscii(Py_ssize_t ulength, char* chars, int clength, int prepend_sign, char padding_char); /* CIntToPyUnicode.proto */ static CYTHON_INLINE PyObject* __Pyx_PyUnicode_From_int(int value, Py_ssize_t width, char padding_char, char format_char); /* CIntToPyUnicode.proto */ static CYTHON_INLINE PyObject* __Pyx_PyUnicode_From_Py_ssize_t(Py_ssize_t value, Py_ssize_t width, char padding_char, char format_char); /* JoinPyUnicode.proto */ static PyObject* __Pyx_PyUnicode_Join(PyObject* value_tuple, Py_ssize_t value_count, Py_ssize_t result_ulength, Py_UCS4 max_char); /* StrEquals.proto */ #if PY_MAJOR_VERSION >= 3 #define __Pyx_PyString_Equals __Pyx_PyUnicode_Equals #else #define __Pyx_PyString_Equals __Pyx_PyBytes_Equals #endif /* PyObjectFormatSimple.proto */ #if CYTHON_COMPILING_IN_PYPY #define __Pyx_PyObject_FormatSimple(s, f) (\ likely(PyUnicode_CheckExact(s)) ? (Py_INCREF(s), s) :\ PyObject_Format(s, f)) #elif PY_MAJOR_VERSION < 3 #define __Pyx_PyObject_FormatSimple(s, f) (\ likely(PyUnicode_CheckExact(s)) ? (Py_INCREF(s), s) :\ likely(PyString_CheckExact(s)) ? PyUnicode_FromEncodedObject(s, NULL, "strict") :\ PyObject_Format(s, f)) #elif CYTHON_USE_TYPE_SLOTS #define __Pyx_PyObject_FormatSimple(s, f) (\ likely(PyUnicode_CheckExact(s)) ? (Py_INCREF(s), s) :\ likely(PyLong_CheckExact(s)) ? PyLong_Type.tp_repr(s) :\ likely(PyFloat_CheckExact(s)) ? PyFloat_Type.tp_repr(s) :\ PyObject_Format(s, f)) #else #define __Pyx_PyObject_FormatSimple(s, f) (\ likely(PyUnicode_CheckExact(s)) ? (Py_INCREF(s), s) :\ PyObject_Format(s, f)) #endif CYTHON_UNUSED static 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 *); /* 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); /* PyObjectCallOneArg.proto */ static CYTHON_INLINE PyObject* __Pyx_PyObject_CallOneArg(PyObject *func, PyObject *arg); /* 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 /* KeywordStringCheck.proto */ static int __Pyx_CheckKeywordStrings(PyObject *kw, const char* function_name, int kw_allowed); /* 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 __Pyx_UNARY_NEG_WOULD_OVERFLOW(x)\ (((x) < 0) & ((unsigned long)(x) == 0-(unsigned long)(x))) /* 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) do {\ 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);\ } while(0) #define __Pyx_GetModuleGlobalNameUncached(var, name) do {\ PY_UINT64_T __pyx_dict_version;\ PyObject *__pyx_dict_cached_value;\ (var) = __Pyx__GetModuleGlobalName(name, &__pyx_dict_version, &__pyx_dict_cached_value);\ } while(0) 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 /* AssertionsEnabled.proto */ #if CYTHON_COMPILING_IN_PYPY && PY_VERSION_HEX < 0x02070600 && !defined(Py_OptimizeFlag) #define __Pyx_init_assertions_enabled() (0) #define __pyx_assertions_enabled() (1) #elif CYTHON_COMPILING_IN_LIMITED_API || (CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030C0000) static int __pyx_assertions_enabled_flag; #define __pyx_assertions_enabled() (__pyx_assertions_enabled_flag) static int __Pyx_init_assertions_enabled(void) { PyObject *builtins, *debug, *debug_str; int flag; builtins = PyEval_GetBuiltins(); if (!builtins) goto bad; debug_str = PyUnicode_FromStringAndSize("__debug__", 9); if (!debug_str) goto bad; debug = PyObject_GetItem(builtins, debug_str); Py_DECREF(debug_str); if (!debug) goto bad; flag = PyObject_IsTrue(debug); Py_DECREF(debug); if (flag == -1) goto bad; __pyx_assertions_enabled_flag = flag; return 0; bad: __pyx_assertions_enabled_flag = 1; return -1; } #else #define __Pyx_init_assertions_enabled() (0) #define __pyx_assertions_enabled() (!Py_OptimizeFlag) #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); /* RaiseNoneIterError.proto */ static CYTHON_INLINE void __Pyx_RaiseNoneNotIterableError(void); /* ExtTypeTest.proto */ static CYTHON_INLINE int __Pyx_TypeTest(PyObject *obj, PyTypeObject *type); /* GetTopmostException.proto */ #if CYTHON_USE_EXC_INFO_STACK && CYTHON_FAST_THREAD_STATE 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); /* ImportDottedModule.proto */ static PyObject *__Pyx_ImportDottedModule(PyObject *name, PyObject *parts_tuple); #if PY_MAJOR_VERSION >= 3 static PyObject *__Pyx_ImportDottedModule_WalkParts(PyObject *module, PyObject *name, PyObject *parts_tuple); #endif /* FastTypeChecks.proto */ #if CYTHON_COMPILING_IN_CPYTHON #define __Pyx_TypeCheck(obj, type) __Pyx_IsSubtype(Py_TYPE(obj), (PyTypeObject *)type) #define __Pyx_TypeCheck2(obj, type1, type2) __Pyx_IsAnySubtype2(Py_TYPE(obj), (PyTypeObject *)type1, (PyTypeObject *)type2) static CYTHON_INLINE int __Pyx_IsSubtype(PyTypeObject *a, PyTypeObject *b); static CYTHON_INLINE int __Pyx_IsAnySubtype2(PyTypeObject *cls, 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_TypeCheck2(obj, type1, type2) (PyObject_TypeCheck(obj, (PyTypeObject *)type1) || PyObject_TypeCheck(obj, (PyTypeObject *)type2)) #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_PyErr_ExceptionMatches2(err1, err2) __Pyx_PyErr_GivenExceptionMatches2(__Pyx_PyErr_CurrentExceptionType(), err1, err2) #define __Pyx_PyException_Check(obj) __Pyx_TypeCheck(obj, PyExc_Exception) CYTHON_UNUSED static 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); #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030d0000 L->ob_item[len] = x; #else PyList_SET_ITEM(list, len, x); #endif __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 /* PySequenceMultiply.proto */ #define __Pyx_PySequence_Multiply_Left(mul, seq) __Pyx_PySequence_Multiply(seq, mul) static CYTHON_INLINE PyObject* __Pyx_PySequence_Multiply(PyObject *seq, Py_ssize_t mul); /* 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); /* RaiseUnboundLocalError.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 */ #if __PYX_LIMITED_VERSION_HEX >= 0x030d00A1 #define __Pyx_HasAttr(o, n) PyObject_HasAttrWithError(o, n) #else static CYTHON_INLINE int __Pyx_HasAttr(PyObject *, PyObject *); #endif /* SliceObject.proto */ #define __Pyx_PyObject_DelSlice(obj, cstart, cstop, py_start, py_stop, py_slice, has_cstart, has_cstop, wraparound)\ __Pyx_PyObject_SetSlice(obj, (PyObject*)NULL, cstart, cstop, py_start, py_stop, py_slice, has_cstart, has_cstop, wraparound) static CYTHON_INLINE int __Pyx_PyObject_SetSlice( PyObject* obj, PyObject* value, 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); /* PyFloatBinop.proto */ #if !CYTHON_COMPILING_IN_PYPY static PyObject* __Pyx_PyFloat_TrueDivideCObj(PyObject *op1, PyObject *op2, double floatval, int inplace, int zerodivision_check); #else #define __Pyx_PyFloat_TrueDivideCObj(op1, op2, floatval, inplace, zerodivision_check)\ (inplace ? PyNumber_InPlaceTrueDivide(op1, op2) : PyNumber_TrueDivide(op1, op2)) #endif /* PyIntCompare.proto */ static CYTHON_INLINE int __Pyx_PyInt_BoolEqObjC(PyObject *op1, PyObject *op2, long intval, long inplace); /* 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 }; /* PyFloatBinop.proto */ #if !CYTHON_COMPILING_IN_PYPY static PyObject* __Pyx_PyFloat_SubtractObjC(PyObject *op1, PyObject *op2, double floatval, int inplace, int zerodivision_check); #else #define __Pyx_PyFloat_SubtractObjC(op1, op2, floatval, inplace, zerodivision_check)\ (inplace ? PyNumber_InPlaceSubtract(op1, op2) : PyNumber_Subtract(op1, op2)) #endif /* PyFloatBinop.proto */ #if !CYTHON_COMPILING_IN_PYPY static PyObject* __Pyx_PyFloat_AddCObj(PyObject *op1, PyObject *op2, double floatval, int inplace, int zerodivision_check); #else #define __Pyx_PyFloat_AddCObj(op1, op2, floatval, inplace, zerodivision_check)\ (inplace ? PyNumber_InPlaceAdd(op1, op2) : PyNumber_Add(op1, op2)) #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 /* IncludeStructmemberH.proto */ #include /* FixUpExtensionType.proto */ #if CYTHON_USE_TYPE_SPECS static int __Pyx_fix_up_extension_type_from_spec(PyType_Spec *spec, PyTypeObject *type); #endif /* PyObjectCallNoArg.proto */ static CYTHON_INLINE PyObject* __Pyx_PyObject_CallNoArg(PyObject *func); /* 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); /* ValidateBasesTuple.proto */ #if CYTHON_COMPILING_IN_CPYTHON || CYTHON_COMPILING_IN_LIMITED_API || CYTHON_USE_TYPE_SPECS static int __Pyx_validate_bases_tuple(const char *type_name, Py_ssize_t dictoffset, PyObject *bases); #endif /* PyType_Ready.proto */ CYTHON_UNUSED static int __Pyx_PyType_Ready(PyTypeObject *t); /* SetVTable.proto */ static int __Pyx_SetVtable(PyTypeObject* typeptr , void* vtable); /* GetVTable.proto */ static void* __Pyx_GetVtable(PyTypeObject *type); /* MergeVTables.proto */ #if !CYTHON_COMPILING_IN_LIMITED_API static int __Pyx_MergeVtables(PyTypeObject *type); #endif /* SetupReduce.proto */ #if !CYTHON_COMPILING_IN_LIMITED_API static int __Pyx_setup_reduce(PyObject* type_obj); #endif /* TypeImport.proto */ #ifndef __PYX_HAVE_RT_ImportType_proto_3_0_10 #define __PYX_HAVE_RT_ImportType_proto_3_0_10 #if defined (__STDC_VERSION__) && __STDC_VERSION__ >= 201112L #include #endif #if (defined (__STDC_VERSION__) && __STDC_VERSION__ >= 201112L) || __cplusplus >= 201103L #define __PYX_GET_STRUCT_ALIGNMENT_3_0_10(s) alignof(s) #else #define __PYX_GET_STRUCT_ALIGNMENT_3_0_10(s) sizeof(void*) #endif enum __Pyx_ImportType_CheckSize_3_0_10 { __Pyx_ImportType_CheckSize_Error_3_0_10 = 0, __Pyx_ImportType_CheckSize_Warn_3_0_10 = 1, __Pyx_ImportType_CheckSize_Ignore_3_0_10 = 2 }; static PyTypeObject *__Pyx_ImportType_3_0_10(PyObject* module, const char *module_name, const char *class_name, size_t size, size_t alignment, enum __Pyx_ImportType_CheckSize_3_0_10 check_size); #endif /* FetchSharedCythonModule.proto */ static PyObject *__Pyx_FetchSharedCythonABIModule(void); /* FetchCommonType.proto */ #if !CYTHON_USE_TYPE_SPECS static PyTypeObject* __Pyx_FetchCommonType(PyTypeObject* type); #else static PyTypeObject* __Pyx_FetchCommonTypeFromSpec(PyObject *module, PyType_Spec *spec, PyObject *bases); #endif /* PyMethodNew.proto */ #if CYTHON_COMPILING_IN_LIMITED_API static PyObject *__Pyx_PyMethod_New(PyObject *func, PyObject *self, PyObject *typ) { PyObject *typesModule=NULL, *methodType=NULL, *result=NULL; CYTHON_UNUSED_VAR(typ); if (!self) return __Pyx_NewRef(func); typesModule = PyImport_ImportModule("types"); if (!typesModule) return NULL; methodType = PyObject_GetAttrString(typesModule, "MethodType"); Py_DECREF(typesModule); if (!methodType) return NULL; result = PyObject_CallFunctionObjArgs(methodType, func, self, NULL); Py_DECREF(methodType); return result; } #elif PY_MAJOR_VERSION >= 3 static PyObject *__Pyx_PyMethod_New(PyObject *func, PyObject *self, PyObject *typ) { CYTHON_UNUSED_VAR(typ); if (!self) return __Pyx_NewRef(func); return PyMethod_New(func, self); } #else #define __Pyx_PyMethod_New PyMethod_New #endif /* PyVectorcallFastCallDict.proto */ #if CYTHON_METH_FASTCALL static CYTHON_INLINE PyObject *__Pyx_PyVectorcall_FastCallDict(PyObject *func, __pyx_vectorcallfunc vc, PyObject *const *args, size_t nargs, PyObject *kw); #endif /* CythonFunctionShared.proto */ #define __Pyx_CyFunction_USED #define __Pyx_CYFUNCTION_STATICMETHOD 0x01 #define __Pyx_CYFUNCTION_CLASSMETHOD 0x02 #define __Pyx_CYFUNCTION_CCLASS 0x04 #define __Pyx_CYFUNCTION_COROUTINE 0x08 #define __Pyx_CyFunction_GetClosure(f)\ (((__pyx_CyFunctionObject *) (f))->func_closure) #if PY_VERSION_HEX < 0x030900B1 || CYTHON_COMPILING_IN_LIMITED_API #define __Pyx_CyFunction_GetClassObj(f)\ (((__pyx_CyFunctionObject *) (f))->func_classobj) #else #define __Pyx_CyFunction_GetClassObj(f)\ ((PyObject*) ((PyCMethodObject *) (f))->mm_class) #endif #define __Pyx_CyFunction_SetClassObj(f, classobj)\ __Pyx__CyFunction_SetClassObj((__pyx_CyFunctionObject *) (f), (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 { #if CYTHON_COMPILING_IN_LIMITED_API PyObject_HEAD PyObject *func; #elif PY_VERSION_HEX < 0x030900B1 PyCFunctionObject func; #else PyCMethodObject func; #endif #if CYTHON_BACKPORT_VECTORCALL __pyx_vectorcallfunc func_vectorcall; #endif #if PY_VERSION_HEX < 0x030500A0 || CYTHON_COMPILING_IN_LIMITED_API 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; #if PY_VERSION_HEX < 0x030900B1 || CYTHON_COMPILING_IN_LIMITED_API PyObject *func_classobj; #endif void *defaults; int defaults_pyobjects; size_t defaults_size; int flags; PyObject *defaults_tuple; PyObject *defaults_kwdict; PyObject *(*defaults_getter)(PyObject *); PyObject *func_annotations; PyObject *func_is_coroutine; } __pyx_CyFunctionObject; #undef __Pyx_CyOrPyCFunction_Check #define __Pyx_CyFunction_Check(obj) __Pyx_TypeCheck(obj, __pyx_CyFunctionType) #define __Pyx_CyOrPyCFunction_Check(obj) __Pyx_TypeCheck2(obj, __pyx_CyFunctionType, &PyCFunction_Type) #define __Pyx_CyFunction_CheckExact(obj) __Pyx_IS_TYPE(obj, __pyx_CyFunctionType) static CYTHON_INLINE int __Pyx__IsSameCyOrCFunction(PyObject *func, void *cfunc); #undef __Pyx_IsSameCFunction #define __Pyx_IsSameCFunction(func, cfunc) __Pyx__IsSameCyOrCFunction(func, cfunc) static PyObject *__Pyx_CyFunction_Init(__pyx_CyFunctionObject* op, PyMethodDef *ml, int flags, PyObject* qualname, PyObject *closure, PyObject *module, PyObject *globals, PyObject* code); static CYTHON_INLINE void __Pyx__CyFunction_SetClassObj(__pyx_CyFunctionObject* f, PyObject* classobj); 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(PyObject *module); #if CYTHON_METH_FASTCALL static PyObject * __Pyx_CyFunction_Vectorcall_NOARGS(PyObject *func, PyObject *const *args, size_t nargsf, PyObject *kwnames); static PyObject * __Pyx_CyFunction_Vectorcall_O(PyObject *func, PyObject *const *args, size_t nargsf, PyObject *kwnames); static PyObject * __Pyx_CyFunction_Vectorcall_FASTCALL_KEYWORDS(PyObject *func, PyObject *const *args, size_t nargsf, PyObject *kwnames); static PyObject * __Pyx_CyFunction_Vectorcall_FASTCALL_KEYWORDS_METHOD(PyObject *func, PyObject *const *args, size_t nargsf, PyObject *kwnames); #if CYTHON_BACKPORT_VECTORCALL #define __Pyx_CyFunction_func_vectorcall(f) (((__pyx_CyFunctionObject*)f)->func_vectorcall) #else #define __Pyx_CyFunction_func_vectorcall(f) (((PyCFunctionObject*)f)->vectorcall) #endif #endif /* CythonFunction.proto */ static PyObject *__Pyx_CyFunction_New(PyMethodDef *ml, int flags, PyObject* qualname, PyObject *closure, PyObject *module, PyObject *globals, PyObject* code); /* 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 */ #if !CYTHON_COMPILING_IN_LIMITED_API 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); #endif /* 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); /* 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_nn___pyx_t_12astroscrappy_12astroscrappy_bool(PyObject *, int writable_flag); /* 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 && (1) && (!0 || __cplusplus) #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 && (1) && (!0 || __cplusplus) #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 /* Arithmetic.proto */ #if CYTHON_CCOMPLEX && (1) && (!0 || __cplusplus) #define __Pyx_c_eq_long__double(a, b) ((a)==(b)) #define __Pyx_c_sum_long__double(a, b) ((a)+(b)) #define __Pyx_c_diff_long__double(a, b) ((a)-(b)) #define __Pyx_c_prod_long__double(a, b) ((a)*(b)) #define __Pyx_c_quot_long__double(a, b) ((a)/(b)) #define __Pyx_c_neg_long__double(a) (-(a)) #ifdef __cplusplus #define __Pyx_c_is_zero_long__double(z) ((z)==(long double)0) #define __Pyx_c_conj_long__double(z) (::std::conj(z)) #if 1 #define __Pyx_c_abs_long__double(z) (::std::abs(z)) #define __Pyx_c_pow_long__double(a, b) (::std::pow(a, b)) #endif #else #define __Pyx_c_is_zero_long__double(z) ((z)==0) #define __Pyx_c_conj_long__double(z) (conjl(z)) #if 1 #define __Pyx_c_abs_long__double(z) (cabsl(z)) #define __Pyx_c_pow_long__double(a, b) (cpowl(a, b)) #endif #endif #else static CYTHON_INLINE int __Pyx_c_eq_long__double(__pyx_t_long_double_complex, __pyx_t_long_double_complex); static CYTHON_INLINE __pyx_t_long_double_complex __Pyx_c_sum_long__double(__pyx_t_long_double_complex, __pyx_t_long_double_complex); static CYTHON_INLINE __pyx_t_long_double_complex __Pyx_c_diff_long__double(__pyx_t_long_double_complex, __pyx_t_long_double_complex); static CYTHON_INLINE __pyx_t_long_double_complex __Pyx_c_prod_long__double(__pyx_t_long_double_complex, __pyx_t_long_double_complex); static CYTHON_INLINE __pyx_t_long_double_complex __Pyx_c_quot_long__double(__pyx_t_long_double_complex, __pyx_t_long_double_complex); static CYTHON_INLINE __pyx_t_long_double_complex __Pyx_c_neg_long__double(__pyx_t_long_double_complex); static CYTHON_INLINE int __Pyx_c_is_zero_long__double(__pyx_t_long_double_complex); static CYTHON_INLINE __pyx_t_long_double_complex __Pyx_c_conj_long__double(__pyx_t_long_double_complex); #if 1 static CYTHON_INLINE long double __Pyx_c_abs_long__double(__pyx_t_long_double_complex); static CYTHON_INLINE __pyx_t_long_double_complex __Pyx_c_pow_long__double(__pyx_t_long_double_complex, __pyx_t_long_double_complex); #endif #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); /* 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_type *acquisition_count, PyThread_type_lock lock); static CYTHON_INLINE int __pyx_sub_acquisition_count_locked( __pyx_atomic_int_type *acquisition_count, PyThread_type_lock lock); #define __pyx_get_slice_count_pointer(memview) (&memview->acquisition_count) #define __PYX_INC_MEMVIEW(slice, have_gil) __Pyx_INC_MEMVIEW(slice, have_gil, __LINE__) #define __PYX_XCLEAR_MEMVIEW(slice, have_gil) __Pyx_XCLEAR_MEMVIEW(slice, have_gil, __LINE__) static CYTHON_INLINE void __Pyx_INC_MEMVIEW(__Pyx_memviewslice *, int, int); static CYTHON_INLINE void __Pyx_XCLEAR_MEMVIEW(__Pyx_memviewslice *, int, int); /* CIntFromPy.proto */ static CYTHON_INLINE int __Pyx_PyInt_As_int(PyObject *); /* CIntToPy.proto */ static CYTHON_INLINE PyObject* __Pyx_PyInt_From_int(int value); /* CIntFromPy.proto */ static CYTHON_INLINE uint8_t __Pyx_PyInt_As_uint8_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 char __Pyx_PyInt_As_char(PyObject *); /* FormatTypeName.proto */ #if CYTHON_COMPILING_IN_LIMITED_API typedef PyObject *__Pyx_TypeName; #define __Pyx_FMT_TYPENAME "%U" static __Pyx_TypeName __Pyx_PyType_GetName(PyTypeObject* tp); #define __Pyx_DECREF_TypeName(obj) Py_XDECREF(obj) #else typedef const char *__Pyx_TypeName; #define __Pyx_FMT_TYPENAME "%.200s" #define __Pyx_PyType_GetName(tp) ((tp)->tp_name) #define __Pyx_DECREF_TypeName(obj) #endif /* CStringEquals.proto */ static CYTHON_INLINE int __Pyx_StrEq(const char *, const char *); /* CheckBinaryVersion.proto */ static unsigned long __Pyx_get_runtime_version(void); static int __Pyx_check_binary_version(unsigned long ct_version, unsigned long rt_version, int allow_newer); /* FunctionImport.proto */ static int __Pyx_ImportFunction_3_0_10(PyObject *module, const char *funcname, void (**f)(void), const char *sig); /* InitStrings.proto */ static int __Pyx_InitStrings(__Pyx_StringTabEntry *t); /* #### Code section: module_declarations ### */ 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_memoryview__get_base(struct __pyx_memoryview_obj *__pyx_v_self); /* 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*/ static PyObject *__pyx_memoryviewslice__get_base(struct __pyx_memoryviewslice_obj *__pyx_v_self); /* proto*/ static CYTHON_INLINE npy_intp __pyx_f_5numpy_5dtype_8itemsize_itemsize(PyArray_Descr *__pyx_v_self); /* proto*/ static CYTHON_INLINE npy_intp __pyx_f_5numpy_5dtype_9alignment_alignment(PyArray_Descr *__pyx_v_self); /* proto*/ static CYTHON_INLINE PyObject *__pyx_f_5numpy_5dtype_6fields_fields(PyArray_Descr *__pyx_v_self); /* proto*/ static CYTHON_INLINE PyObject *__pyx_f_5numpy_5dtype_5names_names(PyArray_Descr *__pyx_v_self); /* proto*/ static CYTHON_INLINE PyArray_ArrayDescr *__pyx_f_5numpy_5dtype_8subarray_subarray(PyArray_Descr *__pyx_v_self); /* proto*/ static CYTHON_INLINE npy_uint64 __pyx_f_5numpy_5dtype_5flags_flags(PyArray_Descr *__pyx_v_self); /* proto*/ static CYTHON_INLINE int __pyx_f_5numpy_9broadcast_7numiter_numiter(PyArrayMultiIterObject *__pyx_v_self); /* proto*/ static CYTHON_INLINE npy_intp __pyx_f_5numpy_9broadcast_4size_size(PyArrayMultiIterObject *__pyx_v_self); /* proto*/ static CYTHON_INLINE npy_intp __pyx_f_5numpy_9broadcast_5index_index(PyArrayMultiIterObject *__pyx_v_self); /* proto*/ static CYTHON_INLINE int __pyx_f_5numpy_9broadcast_2nd_nd(PyArrayMultiIterObject *__pyx_v_self); /* proto*/ static CYTHON_INLINE npy_intp *__pyx_f_5numpy_9broadcast_10dimensions_dimensions(PyArrayMultiIterObject *__pyx_v_self); /* proto*/ static CYTHON_INLINE void **__pyx_f_5numpy_9broadcast_5iters_iters(PyArrayMultiIterObject *__pyx_v_self); /* proto*/ static CYTHON_INLINE PyObject *__pyx_f_5numpy_7ndarray_4base_base(PyArrayObject *__pyx_v_self); /* proto*/ static CYTHON_INLINE PyArray_Descr *__pyx_f_5numpy_7ndarray_5descr_descr(PyArrayObject *__pyx_v_self); /* proto*/ static CYTHON_INLINE int __pyx_f_5numpy_7ndarray_4ndim_ndim(PyArrayObject *__pyx_v_self); /* proto*/ static CYTHON_INLINE npy_intp *__pyx_f_5numpy_7ndarray_5shape_shape(PyArrayObject *__pyx_v_self); /* proto*/ static CYTHON_INLINE npy_intp *__pyx_f_5numpy_7ndarray_7strides_strides(PyArrayObject *__pyx_v_self); /* proto*/ static CYTHON_INLINE npy_intp __pyx_f_5numpy_7ndarray_4size_size(PyArrayObject *__pyx_v_self); /* proto*/ static CYTHON_INLINE char *__pyx_f_5numpy_7ndarray_4data_data(PyArrayObject *__pyx_v_self); /* proto*/ /* Module declarations from "libc.string" */ /* Module declarations from "libc.stdio" */ /* Module declarations from "__builtin__" */ /* Module declarations from "cpython.type" */ /* Module declarations from "cpython" */ /* Module declarations from "cpython.object" */ /* Module declarations from "cpython.ref" */ /* Module declarations from "numpy" */ /* Module declarations from "numpy" */ static CYTHON_INLINE int __pyx_f_5numpy_import_array(void); /*proto*/ /* Module declarations from "cython.view" */ /* Module declarations from "cython.dataclasses" */ /* Module declarations from "cython" */ /* Module declarations from "astroscrappy.utils.median_utils" */ static float (*__pyx_f_12astroscrappy_5utils_12median_utils_cymedian)(float *, int); /*proto*/ /* Module declarations from "libc.stdint" */ /* Module declarations from "libc.stdlib" */ /* Module declarations from "astroscrappy.astroscrappy" */ static PyObject *__pyx_collections_abc_Sequence = 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 void __pyx_f_12astroscrappy_12astroscrappy_clean_meanmask(__Pyx_memviewslice, __Pyx_memviewslice, __Pyx_memviewslice, int, int, float); /*proto*/ static void __pyx_f_12astroscrappy_12astroscrappy_clean_median(__Pyx_memviewslice, __Pyx_memviewslice, int, int); /*proto*/ static void __pyx_f_12astroscrappy_12astroscrappy_clean_medmask(__Pyx_memviewslice, __Pyx_memviewslice, __Pyx_memviewslice, int, int, float); /*proto*/ static void __pyx_f_12astroscrappy_12astroscrappy_clean_idwinterp(__Pyx_memviewslice, __Pyx_memviewslice, __Pyx_memviewslice, int, int, float); /*proto*/ static PyObject *__pyx_f_12astroscrappy_12astroscrappy_moffatkernel(float, float, int); /*proto*/ static int __pyx_array_allocate_buffer(struct __pyx_array_obj *); /*proto*/ static struct __pyx_array_obj *__pyx_array_new(PyObject *, Py_ssize_t, char *, char *, char *); /*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 int 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 *, PyObject *, int); /*proto*/ static int __pyx_memoryview_err(PyObject *, PyObject *); /*proto*/ static int __pyx_memoryview_err_no_memory(void); /*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*/ /* #### Code section: typeinfo ### */ static __Pyx_TypeInfo __Pyx_TypeInfo_nn___pyx_t_5numpy_float32_t = { "float32_t", NULL, sizeof(__pyx_t_5numpy_float32_t), { 0 }, 0, 'R', 0, 0 }; static __Pyx_TypeInfo __Pyx_TypeInfo_nn___pyx_t_5numpy_uint8_t = { "uint8_t", NULL, sizeof(__pyx_t_5numpy_uint8_t), { 0 }, 0, __PYX_IS_UNSIGNED(__pyx_t_5numpy_uint8_t) ? 'U' : 'I', __PYX_IS_UNSIGNED(__pyx_t_5numpy_uint8_t), 0 }; static __Pyx_TypeInfo __Pyx_TypeInfo_float = { "float", NULL, sizeof(float), { 0 }, 0, 'R', 0, 0 }; static __Pyx_TypeInfo __Pyx_TypeInfo_nn___pyx_t_12astroscrappy_12astroscrappy_bool = { "bool", NULL, sizeof(__pyx_t_12astroscrappy_12astroscrappy_bool), { 0 }, 0, __PYX_IS_UNSIGNED(__pyx_t_12astroscrappy_12astroscrappy_bool) ? 'U' : 'I', __PYX_IS_UNSIGNED(__pyx_t_12astroscrappy_12astroscrappy_bool), 0 }; /* #### Code section: before_global_var ### */ #define __Pyx_MODULE_NAME "astroscrappy.astroscrappy" extern int __pyx_module_is_main_astroscrappy__astroscrappy; int __pyx_module_is_main_astroscrappy__astroscrappy = 0; /* Implementation of "astroscrappy.astroscrappy" */ /* #### Code section: global_var ### */ static PyObject *__pyx_builtin_ValueError; static PyObject *__pyx_builtin_print; static PyObject *__pyx_builtin_range; static PyObject *__pyx_builtin___import__; static PyObject *__pyx_builtin_MemoryError; static PyObject *__pyx_builtin_enumerate; static PyObject *__pyx_builtin_TypeError; static PyObject *__pyx_builtin_AssertionError; static PyObject *__pyx_builtin_Ellipsis; static PyObject *__pyx_builtin_id; static PyObject *__pyx_builtin_IndexError; static PyObject *__pyx_builtin_ImportError; /* #### Code section: string_decls ### */ static const char __pyx_k_[] = ": "; static const char __pyx_k_C[] = "C"; static const char __pyx_k_O[] = "O"; static const char __pyx_k_c[] = "c"; static const char __pyx_k_f[] = "f"; static const char __pyx_k_i[] = "i"; static const char __pyx_k_j[] = "j"; static const char __pyx_k_s[] = "s"; static const char __pyx_k_x[] = "x"; static const char __pyx_k_y[] = "y"; static const char __pyx_k__2[] = "."; static const char __pyx_k__3[] = "*"; static const char __pyx_k__6[] = "'"; static const char __pyx_k__7[] = ")"; static const char __pyx_k_gc[] = "gc"; static const char __pyx_k_id[] = "id"; static const char __pyx_k_m5[] = "m5"; static const char __pyx_k_m7[] = "m7"; static const char __pyx_k_np[] = "np"; static const char __pyx_k_nx[] = "nx"; static const char __pyx_k_ny[] = "ny"; static const char __pyx_k_r2[] = "r2"; static const char __pyx_k_sp[] = "sp"; static const char __pyx_k__38[] = "?"; static const char __pyx_k_abc[] = "abc"; static const char __pyx_k_and[] = " and "; static const char __pyx_k_bkg[] = "bkg"; static const char __pyx_k_exp[] = "exp"; static const char __pyx_k_got[] = " (got "; static const char __pyx_k_idw[] = "idw"; static const char __pyx_k_new[] = "__new__"; static const char __pyx_k_obj[] = "obj"; static const char __pyx_k_sum[] = "sum"; static const char __pyx_k_sys[] = "sys"; static const char __pyx_k_base[] = "base"; static const char __pyx_k_bool[] = "bool_"; static const char __pyx_k_copy[] = "copy"; static const char __pyx_k_data[] = "data"; static const char __pyx_k_dict[] = "__dict__"; static const char __pyx_k_gain[] = "gain"; static const char __pyx_k_main[] = "__main__"; static const char __pyx_k_mask[] = "mask"; 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_psfk[] = "psfk"; static const char __pyx_k_size[] = "size"; static const char __pyx_k_spec[] = "__spec__"; static const char __pyx_k_sqrt[] = "sqrt"; static const char __pyx_k_step[] = "step"; static const char __pyx_k_stop[] = "stop"; static const char __pyx_k_test[] = "__test__"; static const char __pyx_k_tile[] = "tile"; static const char __pyx_k_ASCII[] = "ASCII"; static const char __pyx_k_array[] = "array"; static const char __pyx_k_class[] = "__class__"; static const char __pyx_k_count[] = "count"; static const char __pyx_k_dtype[] = "dtype"; static const char __pyx_k_empty[] = "empty"; static const char __pyx_k_error[] = "error"; static const char __pyx_k_flags[] = "flags"; static const char __pyx_k_gauss[] = "gauss"; static const char __pyx_k_inbkg[] = "inbkg"; static const char __pyx_k_indat[] = "indat"; static const char __pyx_k_index[] = "index"; static const char __pyx_k_invar[] = "invar"; static const char __pyx_k_niter[] = "niter"; static const char __pyx_k_noise[] = "noise"; static const char __pyx_k_numcr[] = "numcr"; static const char __pyx_k_numpy[] = "numpy"; static const char __pyx_k_order[] = "order"; static const char __pyx_k_power[] = "power"; static const char __pyx_k_print[] = "print"; static const char __pyx_k_range[] = "range"; static const char __pyx_k_rebin[] = "rebin"; static const char __pyx_k_shape[] = "shape"; static const char __pyx_k_start[] = "start"; static const char __pyx_k_uint8[] = "uint8"; static const char __pyx_k_utils[] = "utils"; static const char __pyx_k_zeros[] = "zeros"; static const char __pyx_k_arange[] = "arange"; static const char __pyx_k_astype[] = "astype"; static const char __pyx_k_conved[] = "conved"; static const char __pyx_k_crmask[] = "crmask"; static const char __pyx_k_enable[] = "enable"; static const char __pyx_k_encode[] = "encode"; static const char __pyx_k_format[] = "format"; static const char __pyx_k_fsmode[] = "fsmode"; static const char __pyx_k_gaussx[] = "gaussx"; static const char __pyx_k_gaussy[] = "gaussy"; static const char __pyx_k_import[] = "__import__"; static const char __pyx_k_inmask[] = "inmask"; static const char __pyx_k_kernel[] = "kernel"; static const char __pyx_k_median[] = "median"; static const char __pyx_k_moffat[] = "moffat"; static const char __pyx_k_name_2[] = "__name__"; static const char __pyx_k_objlim[] = "objlim"; static const char __pyx_k_pickle[] = "pickle"; static const char __pyx_k_reduce[] = "__reduce__"; static const char __pyx_k_sepmed[] = "sepmed"; static const char __pyx_k_sigma2[] = "sigma2"; static const char __pyx_k_struct[] = "struct"; static const char __pyx_k_subsam[] = "subsam"; static const char __pyx_k_unpack[] = "unpack"; static const char __pyx_k_update[] = "update"; static const char __pyx_k_asarray[] = "asarray"; static const char __pyx_k_cosmics[] = "cosmics"; static const char __pyx_k_dilate3[] = "dilate3"; static const char __pyx_k_dilate5[] = "dilate5"; static const char __pyx_k_disable[] = "disable"; static const char __pyx_k_float32[] = "float32"; static const char __pyx_k_fortran[] = "fortran"; static const char __pyx_k_goodpix[] = "goodpix"; static const char __pyx_k_goodvar[] = "goodvar"; static const char __pyx_k_medmask[] = "medmask"; static const char __pyx_k_memview[] = "memview"; static const char __pyx_k_psfbeta[] = "psfbeta"; static const char __pyx_k_psffwhm[] = "psffwhm"; static const char __pyx_k_psfsize[] = "psfsize"; static const char __pyx_k_sigclip[] = "sigclip"; static const char __pyx_k_sigfrac[] = "sigfrac"; static const char __pyx_k_verbose[] = "verbose"; static const char __pyx_k_Ellipsis[] = "Ellipsis"; static const char __pyx_k_Sequence[] = "Sequence"; static const char __pyx_k_cleanarr[] = "cleanarr"; static const char __pyx_k_convolve[] = "convolve"; static const char __pyx_k_getstate[] = "__getstate__"; static const char __pyx_k_gooddata[] = "gooddata"; static const char __pyx_k_igoodpix[] = "igoodpix"; static const char __pyx_k_itemsize[] = "itemsize"; static const char __pyx_k_kernsize[] = "kernsize"; static const char __pyx_k_meanmask[] = "meanmask"; static const char __pyx_k_medfilt3[] = "medfilt3"; static const char __pyx_k_medfilt5[] = "medfilt5"; static const char __pyx_k_medfilt7[] = "medfilt7"; static const char __pyx_k_psfmodel[] = "psfmodel"; static const char __pyx_k_pyx_type[] = "__pyx_type"; static const char __pyx_k_register[] = "register"; static const char __pyx_k_satlevel[] = "satlevel"; static const char __pyx_k_setstate[] = "__setstate__"; static const char __pyx_k_Iteration[] = "Iteration {}:"; static const char __pyx_k_TypeError[] = "TypeError"; static const char __pyx_k_clean_var[] = "clean_var"; static const char __pyx_k_cleantype[] = "cleantype"; static const char __pyx_k_enumerate[] = "enumerate"; static const char __pyx_k_grow_mask[] = "grow_mask"; static const char __pyx_k_isenabled[] = "isenabled"; static const char __pyx_k_pyx_state[] = "__pyx_state"; static const char __pyx_k_readnoise[] = "readnoise"; static const char __pyx_k_reduce_ex[] = "__reduce_ex__"; static const char __pyx_k_satpixels[] = "satpixels"; static const char __pyx_k_subsample[] = "subsample"; static const char __pyx_k_transpose[] = "transpose"; static const char __pyx_k_IndexError[] = "IndexError"; static const char __pyx_k_ValueError[] = "ValueError"; static const char __pyx_k_empty_like[] = "empty_like"; static const char __pyx_k_logical_or[] = "logical_or"; static const char __pyx_k_pyx_result[] = "__pyx_result"; static const char __pyx_k_pyx_vtable[] = "__pyx_vtable__"; static const char __pyx_k_sigcliplow[] = "sigcliplow"; static const char __pyx_k_ImportError[] = "ImportError"; static const char __pyx_k_MemoryError[] = "MemoryError"; static const char __pyx_k_PickleError[] = "PickleError"; static const char __pyx_k_collections[] = "collections"; static const char __pyx_k_gausskernel[] = "gausskernel"; static const char __pyx_k_logical_and[] = "logical_and"; static const char __pyx_k_logical_not[] = "logical_not"; static const char __pyx_k_sepmedfilt5[] = "sepmedfilt5"; static const char __pyx_k_sepmedfilt7[] = "sepmedfilt7"; static const char __pyx_k_sepmedfilt9[] = "sepmedfilt9"; static const char __pyx_k_update_mask[] = "update_mask"; static const char __pyx_k_dilsatpixels[] = "dilsatpixels"; static const char __pyx_k_gaussxkernel[] = "gaussxkernel"; static const char __pyx_k_gaussykernel[] = "gaussykernel"; static const char __pyx_k_initializing[] = "_initializing"; static const char __pyx_k_is_coroutine[] = "_is_coroutine"; static const char __pyx_k_pyx_checksum[] = "__pyx_checksum"; static const char __pyx_k_stringsource[] = ""; static const char __pyx_k_version_info[] = "version_info"; static const char __pyx_k_class_getitem[] = "__class_getitem__"; static const char __pyx_k_reduce_cython[] = "__reduce_cython__"; static const char __pyx_k_AssertionError[] = "AssertionError"; static const char __pyx_k_detect_cosmics[] = "detect_cosmics"; static const char __pyx_k_View_MemoryView[] = "View.MemoryView"; static const char __pyx_k_allocate_buffer[] = "allocate_buffer"; static const char __pyx_k_collections_abc[] = "collections.abc"; static const char __pyx_k_dtype_is_object[] = "dtype_is_object"; static const char __pyx_k_laplaceconvolve[] = "laplaceconvolve"; static const char __pyx_k_pyx_PickleError[] = "__pyx_PickleError"; static const char __pyx_k_setstate_cython[] = "__setstate_cython__"; static const char __pyx_k_background_level[] = "background_level"; static const char __pyx_k_pyx_unpickle_Enum[] = "__pyx_unpickle_Enum"; static const char __pyx_k_asyncio_coroutines[] = "asyncio.coroutines"; static const char __pyx_k_cline_in_traceback[] = "cline_in_traceback"; static const char __pyx_k_strided_and_direct[] = ""; static const char __pyx_k_background_var_level[] = "background_var_level"; static const char __pyx_k_strided_and_indirect[] = ""; static const char __pyx_k_Invalid_shape_in_axis[] = "Invalid shape in axis "; static const char __pyx_k_contiguous_and_direct[] = ""; static const char __pyx_k_Cannot_index_with_type[] = "Cannot index with type '"; 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_Dimension_d_is_not_direct[] = "Dimension %d is not direct"; static const char __pyx_k_astroscrappy_astroscrappy[] = "astroscrappy.astroscrappy"; static const char __pyx_k_Index_out_of_bounds_axis_d[] = "Index out of bounds (axis %d)"; static const char __pyx_k_Step_may_not_be_zero_axis_d[] = "Step may not be zero (axis %d)"; static const char __pyx_k_itemsize_0_for_cython_array[] = "itemsize <= 0 for cython.array"; static const char __pyx_k_cosmic_pixels_this_iteration[] = "{} cosmic pixels this iteration"; static const char __pyx_k_astroscrappy_astroscrappy_pyx[] = "astroscrappy/astroscrappy.pyx"; static const char __pyx_k_unable_to_allocate_array_data[] = "unable to allocate array data."; static const char __pyx_k_Starting_L_A_Cosmic_iterations[] = "Starting {} L.A.Cosmic iterations"; static const char __pyx_k_strided_and_direct_or_indirect[] = ""; static const char __pyx_k_Name_astroscrappy_The_Speedy_Co[] = "\nName : astroscrappy: The Speedy Cosmic Ray Annihilation Package in Python\nAuthor : Curtis McCully\nDate : October 2014\n"; static const char __pyx_k_All_dimensions_preceding_dimensi[] = "All dimensions preceding dimension %d must be indexed and not sliced"; 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_Cannot_transpose_memoryview_with[] = "Cannot transpose memoryview with indirect dimensions"; static const char __pyx_k_Empty_shape_tuple_for_cython_arr[] = "Empty shape tuple for cython.array"; static const char __pyx_k_Incompatible_checksums_0x_x_vs_0[] = "Incompatible checksums (0x%x vs (0x82a3537, 0x6ae9995, 0xb068931) = (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 "; static const char __pyx_k_Out_of_bounds_on_buffer_access_a[] = "Out of bounds on buffer access (axis "; static const char __pyx_k_Please_choose_a_supported_PSF_mo[] = "Please choose a supported PSF model."; static const char __pyx_k_Please_choose_a_valid_fine_struc[] = "Please choose a valid fine structure mode."; static const char __pyx_k_Unable_to_convert_item_to_object[] = "Unable to convert item to object"; static const char __pyx_k_cleantype_must_be_one_of_the_fol[] = "cleantype must be one of the following values:\n [median, meanmask, medmask, idw]"; static const char __pyx_k_got_differing_extents_in_dimensi[] = "got differing extents in dimension "; 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_multiarray_failed_to[] = "numpy._core.multiarray failed to import"; static const char __pyx_k_numpy__core_umath_failed_to_impo[] = "numpy._core.umath failed to import"; static const char __pyx_k_unable_to_allocate_shape_and_str[] = "unable to allocate shape and strides."; /* #### Code section: decls ### */ 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___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_pf_12astroscrappy_12astroscrappy_detect_cosmics(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_indat, PyObject *__pyx_v_inmask, PyObject *__pyx_v_inbkg, PyObject *__pyx_v_invar, float __pyx_v_sigclip, float __pyx_v_sigfrac, float __pyx_v_objlim, float __pyx_v_gain, float __pyx_v_readnoise, float __pyx_v_satlevel, int __pyx_v_niter, PyObject *__pyx_v_sepmed, PyObject *__pyx_v_cleantype, PyObject *__pyx_v_fsmode, PyObject *__pyx_v_psfmodel, float __pyx_v_psffwhm, int __pyx_v_psfsize, PyObject *__pyx_v_psfk, float __pyx_v_psfbeta, PyObject *__pyx_v_verbose); /* proto */ static PyObject *__pyx_pf_12astroscrappy_12astroscrappy_2update_mask(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_data, PyArrayObject *__pyx_v_mask, float __pyx_v_satlevel, __pyx_t_12astroscrappy_12astroscrappy_bool __pyx_v_sepmed); /* proto */ static PyObject *__pyx_pf_12astroscrappy_12astroscrappy_4gausskernel(CYTHON_UNUSED PyObject *__pyx_self, float __pyx_v_psffwhm, int __pyx_v_kernsize); /* proto */ static PyObject *__pyx_pf_12astroscrappy_12astroscrappy_6gaussxkernel(CYTHON_UNUSED PyObject *__pyx_self, float __pyx_v_psffwhm, int __pyx_v_kernsize); /* proto */ static PyObject *__pyx_pf_12astroscrappy_12astroscrappy_8gaussykernel(CYTHON_UNUSED PyObject *__pyx_self, float __pyx_v_psffwhm, int __pyx_v_kernsize); /* 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*/ /* #### Code section: late_includes ### */ /* #### Code section: module_state ### */ typedef struct { PyObject *__pyx_d; PyObject *__pyx_b; PyObject *__pyx_cython_runtime; PyObject *__pyx_empty_tuple; PyObject *__pyx_empty_bytes; PyObject *__pyx_empty_unicode; #ifdef __Pyx_CyFunction_USED PyTypeObject *__pyx_CyFunctionType; #endif #ifdef __Pyx_FusedFunction_USED PyTypeObject *__pyx_FusedFunctionType; #endif #ifdef __Pyx_Generator_USED PyTypeObject *__pyx_GeneratorType; #endif #ifdef __Pyx_IterableCoroutine_USED PyTypeObject *__pyx_IterableCoroutineType; #endif #ifdef __Pyx_Coroutine_USED PyTypeObject *__pyx_CoroutineAwaitType; #endif #ifdef __Pyx_Coroutine_USED PyTypeObject *__pyx_CoroutineType; #endif #if CYTHON_USE_MODULE_STATE #endif #if CYTHON_USE_MODULE_STATE #endif #if CYTHON_USE_MODULE_STATE #endif #if CYTHON_USE_MODULE_STATE #endif PyTypeObject *__pyx_ptype_7cpython_4type_type; #if CYTHON_USE_MODULE_STATE #endif #if CYTHON_USE_MODULE_STATE #endif #if CYTHON_USE_MODULE_STATE #endif #if CYTHON_USE_MODULE_STATE #endif #if CYTHON_USE_MODULE_STATE #endif PyTypeObject *__pyx_ptype_5numpy_dtype; PyTypeObject *__pyx_ptype_5numpy_flatiter; PyTypeObject *__pyx_ptype_5numpy_broadcast; PyTypeObject *__pyx_ptype_5numpy_ndarray; PyTypeObject *__pyx_ptype_5numpy_generic; PyTypeObject *__pyx_ptype_5numpy_number; PyTypeObject *__pyx_ptype_5numpy_integer; PyTypeObject *__pyx_ptype_5numpy_signedinteger; PyTypeObject *__pyx_ptype_5numpy_unsignedinteger; PyTypeObject *__pyx_ptype_5numpy_inexact; PyTypeObject *__pyx_ptype_5numpy_floating; PyTypeObject *__pyx_ptype_5numpy_complexfloating; PyTypeObject *__pyx_ptype_5numpy_flexible; PyTypeObject *__pyx_ptype_5numpy_character; PyTypeObject *__pyx_ptype_5numpy_ufunc; #if CYTHON_USE_MODULE_STATE #endif #if CYTHON_USE_MODULE_STATE #endif #if CYTHON_USE_MODULE_STATE #endif #if CYTHON_USE_MODULE_STATE #endif #if CYTHON_USE_MODULE_STATE #endif #if CYTHON_USE_MODULE_STATE #endif #if CYTHON_USE_MODULE_STATE PyObject *__pyx_type___pyx_array; PyObject *__pyx_type___pyx_MemviewEnum; PyObject *__pyx_type___pyx_memoryview; PyObject *__pyx_type___pyx_memoryviewslice; #endif PyTypeObject *__pyx_array_type; PyTypeObject *__pyx_MemviewEnum_type; PyTypeObject *__pyx_memoryview_type; PyTypeObject *__pyx_memoryviewslice_type; PyObject *__pyx_kp_u_; PyObject *__pyx_n_s_ASCII; PyObject *__pyx_kp_s_All_dimensions_preceding_dimensi; PyObject *__pyx_n_s_AssertionError; PyObject *__pyx_kp_s_Buffer_view_does_not_expose_stri; PyObject *__pyx_n_u_C; PyObject *__pyx_kp_s_Can_only_create_a_buffer_that_is; PyObject *__pyx_kp_s_Cannot_assign_to_read_only_memor; PyObject *__pyx_kp_s_Cannot_create_writable_memory_vi; PyObject *__pyx_kp_u_Cannot_index_with_type; PyObject *__pyx_kp_s_Cannot_transpose_memoryview_with; PyObject *__pyx_kp_s_Dimension_d_is_not_direct; PyObject *__pyx_n_s_Ellipsis; PyObject *__pyx_kp_s_Empty_shape_tuple_for_cython_arr; PyObject *__pyx_n_s_ImportError; PyObject *__pyx_kp_s_Incompatible_checksums_0x_x_vs_0; PyObject *__pyx_n_s_IndexError; PyObject *__pyx_kp_s_Index_out_of_bounds_axis_d; PyObject *__pyx_kp_s_Indirect_dimensions_not_supporte; PyObject *__pyx_kp_u_Invalid_mode_expected_c_or_fortr; PyObject *__pyx_kp_u_Invalid_shape_in_axis; PyObject *__pyx_kp_u_Iteration; PyObject *__pyx_n_s_MemoryError; PyObject *__pyx_kp_s_MemoryView_of_r_at_0x_x; PyObject *__pyx_kp_s_MemoryView_of_r_object; PyObject *__pyx_n_b_O; PyObject *__pyx_kp_u_Out_of_bounds_on_buffer_access_a; PyObject *__pyx_n_s_PickleError; PyObject *__pyx_kp_u_Please_choose_a_supported_PSF_mo; PyObject *__pyx_kp_u_Please_choose_a_valid_fine_struc; PyObject *__pyx_n_s_Sequence; PyObject *__pyx_kp_u_Starting_L_A_Cosmic_iterations; PyObject *__pyx_kp_s_Step_may_not_be_zero_axis_d; PyObject *__pyx_n_s_TypeError; PyObject *__pyx_kp_s_Unable_to_convert_item_to_object; PyObject *__pyx_n_s_ValueError; PyObject *__pyx_n_s_View_MemoryView; PyObject *__pyx_kp_u__2; PyObject *__pyx_n_s__3; PyObject *__pyx_n_s__38; PyObject *__pyx_kp_u__6; PyObject *__pyx_kp_u__7; PyObject *__pyx_n_s_abc; PyObject *__pyx_n_s_allocate_buffer; PyObject *__pyx_kp_u_and; PyObject *__pyx_n_s_arange; PyObject *__pyx_n_s_array; PyObject *__pyx_n_s_asarray; PyObject *__pyx_n_s_astroscrappy_astroscrappy; PyObject *__pyx_kp_s_astroscrappy_astroscrappy_pyx; PyObject *__pyx_n_s_astype; PyObject *__pyx_n_s_asyncio_coroutines; PyObject *__pyx_n_s_background_level; PyObject *__pyx_n_s_background_var_level; PyObject *__pyx_n_s_base; PyObject *__pyx_n_s_bkg; PyObject *__pyx_n_s_bool; PyObject *__pyx_n_s_c; PyObject *__pyx_n_u_c; PyObject *__pyx_n_s_class; PyObject *__pyx_n_s_class_getitem; PyObject *__pyx_n_s_clean_var; PyObject *__pyx_n_s_cleanarr; PyObject *__pyx_n_s_cleantype; PyObject *__pyx_kp_u_cleantype_must_be_one_of_the_fol; PyObject *__pyx_n_s_cline_in_traceback; PyObject *__pyx_n_s_collections; PyObject *__pyx_kp_s_collections_abc; PyObject *__pyx_kp_s_contiguous_and_direct; PyObject *__pyx_kp_s_contiguous_and_indirect; PyObject *__pyx_n_s_conved; PyObject *__pyx_n_s_convolve; PyObject *__pyx_n_u_convolve; PyObject *__pyx_n_s_copy; PyObject *__pyx_kp_u_cosmic_pixels_this_iteration; PyObject *__pyx_n_s_cosmics; PyObject *__pyx_n_s_count; PyObject *__pyx_n_s_crmask; PyObject *__pyx_n_s_data; PyObject *__pyx_n_s_detect_cosmics; PyObject *__pyx_n_s_dict; PyObject *__pyx_n_s_dilate3; PyObject *__pyx_n_s_dilate5; PyObject *__pyx_n_s_dilsatpixels; PyObject *__pyx_kp_u_disable; PyObject *__pyx_n_s_dtype; PyObject *__pyx_n_s_dtype_is_object; PyObject *__pyx_n_s_empty; PyObject *__pyx_n_s_empty_like; PyObject *__pyx_kp_u_enable; PyObject *__pyx_n_s_encode; PyObject *__pyx_n_s_enumerate; PyObject *__pyx_n_s_error; PyObject *__pyx_n_s_exp; PyObject *__pyx_n_s_f; PyObject *__pyx_n_s_flags; PyObject *__pyx_n_s_float32; PyObject *__pyx_n_s_format; PyObject *__pyx_n_s_fortran; PyObject *__pyx_n_u_fortran; PyObject *__pyx_n_s_fsmode; PyObject *__pyx_n_s_gain; PyObject *__pyx_n_u_gauss; PyObject *__pyx_n_s_gausskernel; PyObject *__pyx_n_u_gaussx; PyObject *__pyx_n_s_gaussxkernel; PyObject *__pyx_n_u_gaussy; PyObject *__pyx_n_s_gaussykernel; PyObject *__pyx_kp_u_gc; PyObject *__pyx_n_s_getstate; PyObject *__pyx_n_s_gooddata; PyObject *__pyx_n_s_goodpix; PyObject *__pyx_n_s_goodvar; PyObject *__pyx_kp_u_got; PyObject *__pyx_kp_u_got_differing_extents_in_dimensi; PyObject *__pyx_n_s_grow_mask; PyObject *__pyx_n_s_i; PyObject *__pyx_n_s_id; PyObject *__pyx_n_u_idw; PyObject *__pyx_n_s_igoodpix; PyObject *__pyx_n_s_import; PyObject *__pyx_n_s_inbkg; PyObject *__pyx_n_s_indat; PyObject *__pyx_n_s_index; PyObject *__pyx_n_s_initializing; PyObject *__pyx_n_s_inmask; PyObject *__pyx_n_s_invar; PyObject *__pyx_n_s_is_coroutine; PyObject *__pyx_kp_u_isenabled; PyObject *__pyx_n_s_itemsize; PyObject *__pyx_kp_s_itemsize_0_for_cython_array; PyObject *__pyx_n_s_j; PyObject *__pyx_n_s_kernel; PyObject *__pyx_n_s_kernsize; PyObject *__pyx_n_s_laplaceconvolve; PyObject *__pyx_n_s_logical_and; PyObject *__pyx_n_s_logical_not; PyObject *__pyx_n_s_logical_or; PyObject *__pyx_n_s_m5; PyObject *__pyx_n_s_m7; PyObject *__pyx_n_s_main; PyObject *__pyx_n_s_mask; PyObject *__pyx_n_u_meanmask; PyObject *__pyx_n_s_medfilt3; PyObject *__pyx_n_s_medfilt5; PyObject *__pyx_n_s_medfilt7; PyObject *__pyx_n_s_median; PyObject *__pyx_n_u_median; PyObject *__pyx_n_u_medmask; PyObject *__pyx_n_s_memview; PyObject *__pyx_n_s_mode; PyObject *__pyx_n_u_moffat; PyObject *__pyx_n_s_name; PyObject *__pyx_n_s_name_2; PyObject *__pyx_n_s_ndim; PyObject *__pyx_n_s_new; PyObject *__pyx_n_s_niter; PyObject *__pyx_kp_s_no_default___reduce___due_to_non; PyObject *__pyx_n_s_noise; PyObject *__pyx_n_s_np; PyObject *__pyx_n_s_numcr; PyObject *__pyx_n_s_numpy; PyObject *__pyx_kp_u_numpy__core_multiarray_failed_to; PyObject *__pyx_kp_u_numpy__core_umath_failed_to_impo; PyObject *__pyx_n_s_nx; PyObject *__pyx_n_s_ny; PyObject *__pyx_n_s_obj; PyObject *__pyx_n_s_objlim; PyObject *__pyx_n_s_order; PyObject *__pyx_n_s_pack; PyObject *__pyx_n_s_pickle; PyObject *__pyx_n_s_power; PyObject *__pyx_n_s_print; PyObject *__pyx_n_s_psfbeta; PyObject *__pyx_n_s_psffwhm; PyObject *__pyx_n_s_psfk; PyObject *__pyx_n_s_psfmodel; PyObject *__pyx_n_s_psfsize; PyObject *__pyx_n_s_pyx_PickleError; PyObject *__pyx_n_s_pyx_checksum; PyObject *__pyx_n_s_pyx_result; PyObject *__pyx_n_s_pyx_state; PyObject *__pyx_n_s_pyx_type; PyObject *__pyx_n_s_pyx_unpickle_Enum; PyObject *__pyx_n_s_pyx_vtable; PyObject *__pyx_n_s_r2; PyObject *__pyx_n_s_range; PyObject *__pyx_n_s_readnoise; PyObject *__pyx_n_s_rebin; PyObject *__pyx_n_s_reduce; PyObject *__pyx_n_s_reduce_cython; PyObject *__pyx_n_s_reduce_ex; PyObject *__pyx_n_s_register; PyObject *__pyx_n_s_s; PyObject *__pyx_n_s_satlevel; PyObject *__pyx_n_s_satpixels; PyObject *__pyx_n_s_sepmed; PyObject *__pyx_n_s_sepmedfilt5; PyObject *__pyx_n_s_sepmedfilt7; PyObject *__pyx_n_s_sepmedfilt9; PyObject *__pyx_n_s_setstate; PyObject *__pyx_n_s_setstate_cython; PyObject *__pyx_n_s_shape; PyObject *__pyx_n_s_sigclip; PyObject *__pyx_n_s_sigcliplow; PyObject *__pyx_n_s_sigfrac; PyObject *__pyx_n_s_sigma2; PyObject *__pyx_n_s_size; PyObject *__pyx_n_s_sp; PyObject *__pyx_n_s_spec; PyObject *__pyx_n_s_sqrt; PyObject *__pyx_n_s_start; PyObject *__pyx_n_s_step; PyObject *__pyx_n_s_stop; PyObject *__pyx_kp_s_strided_and_direct; PyObject *__pyx_kp_s_strided_and_direct_or_indirect; PyObject *__pyx_kp_s_strided_and_indirect; PyObject *__pyx_kp_s_stringsource; PyObject *__pyx_n_s_struct; PyObject *__pyx_n_s_subsam; PyObject *__pyx_n_s_subsample; PyObject *__pyx_n_s_sum; PyObject *__pyx_n_s_sys; PyObject *__pyx_n_s_test; PyObject *__pyx_n_s_tile; PyObject *__pyx_n_s_transpose; PyObject *__pyx_n_s_uint8; PyObject *__pyx_kp_s_unable_to_allocate_array_data; PyObject *__pyx_kp_s_unable_to_allocate_shape_and_str; PyObject *__pyx_n_s_unpack; PyObject *__pyx_n_s_update; PyObject *__pyx_n_s_update_mask; PyObject *__pyx_n_s_utils; PyObject *__pyx_n_s_verbose; PyObject *__pyx_n_s_version_info; PyObject *__pyx_n_s_x; PyObject *__pyx_n_s_y; PyObject *__pyx_n_s_zeros; PyObject *__pyx_float_0_; PyObject *__pyx_float_1_; PyObject *__pyx_float_0_0; PyObject *__pyx_float_0_5; PyObject *__pyx_float_1_0; PyObject *__pyx_float_2_0; PyObject *__pyx_float_0_01; PyObject *__pyx_float_0_00001; PyObject *__pyx_float_0_4472136; PyObject *__pyx_float_0_35355339; PyObject *__pyx_float_0_70710678; PyObject *__pyx_float_neg_0_5; PyObject *__pyx_int_0; PyObject *__pyx_int_1; PyObject *__pyx_int_2; PyObject *__pyx_int_3; PyObject *__pyx_int_112105877; PyObject *__pyx_int_136983863; PyObject *__pyx_int_184977713; PyObject *__pyx_int_neg_1; PyObject *__pyx_slice__5; PyObject *__pyx_tuple__4; PyObject *__pyx_tuple__8; PyObject *__pyx_tuple__9; PyObject *__pyx_slice__13; PyObject *__pyx_tuple__10; PyObject *__pyx_tuple__11; PyObject *__pyx_tuple__12; PyObject *__pyx_tuple__14; PyObject *__pyx_tuple__15; PyObject *__pyx_tuple__16; PyObject *__pyx_tuple__17; PyObject *__pyx_tuple__18; PyObject *__pyx_tuple__19; PyObject *__pyx_tuple__20; PyObject *__pyx_tuple__21; PyObject *__pyx_tuple__22; PyObject *__pyx_tuple__23; PyObject *__pyx_tuple__24; PyObject *__pyx_tuple__25; PyObject *__pyx_tuple__26; PyObject *__pyx_tuple__28; PyObject *__pyx_tuple__30; PyObject *__pyx_tuple__32; PyObject *__pyx_tuple__34; PyObject *__pyx_tuple__36; PyObject *__pyx_codeobj__27; PyObject *__pyx_codeobj__29; PyObject *__pyx_codeobj__31; PyObject *__pyx_codeobj__33; PyObject *__pyx_codeobj__35; PyObject *__pyx_codeobj__37; } __pyx_mstate; #if CYTHON_USE_MODULE_STATE #ifdef __cplusplus namespace { extern struct PyModuleDef __pyx_moduledef; } /* anonymous namespace */ #else static struct PyModuleDef __pyx_moduledef; #endif #define __pyx_mstate(o) ((__pyx_mstate *)__Pyx_PyModule_GetState(o)) #define __pyx_mstate_global (__pyx_mstate(PyState_FindModule(&__pyx_moduledef))) #define __pyx_m (PyState_FindModule(&__pyx_moduledef)) #else static __pyx_mstate __pyx_mstate_global_static = #ifdef __cplusplus {}; #else {0}; #endif static __pyx_mstate *__pyx_mstate_global = &__pyx_mstate_global_static; #endif /* #### Code section: module_state_clear ### */ #if CYTHON_USE_MODULE_STATE static int __pyx_m_clear(PyObject *m) { __pyx_mstate *clear_module_state = __pyx_mstate(m); if (!clear_module_state) return 0; Py_CLEAR(clear_module_state->__pyx_d); Py_CLEAR(clear_module_state->__pyx_b); Py_CLEAR(clear_module_state->__pyx_cython_runtime); Py_CLEAR(clear_module_state->__pyx_empty_tuple); Py_CLEAR(clear_module_state->__pyx_empty_bytes); Py_CLEAR(clear_module_state->__pyx_empty_unicode); #ifdef __Pyx_CyFunction_USED Py_CLEAR(clear_module_state->__pyx_CyFunctionType); #endif #ifdef __Pyx_FusedFunction_USED Py_CLEAR(clear_module_state->__pyx_FusedFunctionType); #endif Py_CLEAR(clear_module_state->__pyx_ptype_7cpython_4type_type); Py_CLEAR(clear_module_state->__pyx_ptype_5numpy_dtype); Py_CLEAR(clear_module_state->__pyx_ptype_5numpy_flatiter); Py_CLEAR(clear_module_state->__pyx_ptype_5numpy_broadcast); Py_CLEAR(clear_module_state->__pyx_ptype_5numpy_ndarray); Py_CLEAR(clear_module_state->__pyx_ptype_5numpy_generic); Py_CLEAR(clear_module_state->__pyx_ptype_5numpy_number); Py_CLEAR(clear_module_state->__pyx_ptype_5numpy_integer); Py_CLEAR(clear_module_state->__pyx_ptype_5numpy_signedinteger); Py_CLEAR(clear_module_state->__pyx_ptype_5numpy_unsignedinteger); Py_CLEAR(clear_module_state->__pyx_ptype_5numpy_inexact); Py_CLEAR(clear_module_state->__pyx_ptype_5numpy_floating); Py_CLEAR(clear_module_state->__pyx_ptype_5numpy_complexfloating); Py_CLEAR(clear_module_state->__pyx_ptype_5numpy_flexible); Py_CLEAR(clear_module_state->__pyx_ptype_5numpy_character); Py_CLEAR(clear_module_state->__pyx_ptype_5numpy_ufunc); Py_CLEAR(clear_module_state->__pyx_array_type); Py_CLEAR(clear_module_state->__pyx_type___pyx_array); Py_CLEAR(clear_module_state->__pyx_MemviewEnum_type); Py_CLEAR(clear_module_state->__pyx_type___pyx_MemviewEnum); Py_CLEAR(clear_module_state->__pyx_memoryview_type); Py_CLEAR(clear_module_state->__pyx_type___pyx_memoryview); Py_CLEAR(clear_module_state->__pyx_memoryviewslice_type); Py_CLEAR(clear_module_state->__pyx_type___pyx_memoryviewslice); Py_CLEAR(clear_module_state->__pyx_kp_u_); Py_CLEAR(clear_module_state->__pyx_n_s_ASCII); Py_CLEAR(clear_module_state->__pyx_kp_s_All_dimensions_preceding_dimensi); Py_CLEAR(clear_module_state->__pyx_n_s_AssertionError); Py_CLEAR(clear_module_state->__pyx_kp_s_Buffer_view_does_not_expose_stri); Py_CLEAR(clear_module_state->__pyx_n_u_C); Py_CLEAR(clear_module_state->__pyx_kp_s_Can_only_create_a_buffer_that_is); Py_CLEAR(clear_module_state->__pyx_kp_s_Cannot_assign_to_read_only_memor); Py_CLEAR(clear_module_state->__pyx_kp_s_Cannot_create_writable_memory_vi); Py_CLEAR(clear_module_state->__pyx_kp_u_Cannot_index_with_type); Py_CLEAR(clear_module_state->__pyx_kp_s_Cannot_transpose_memoryview_with); Py_CLEAR(clear_module_state->__pyx_kp_s_Dimension_d_is_not_direct); Py_CLEAR(clear_module_state->__pyx_n_s_Ellipsis); Py_CLEAR(clear_module_state->__pyx_kp_s_Empty_shape_tuple_for_cython_arr); Py_CLEAR(clear_module_state->__pyx_n_s_ImportError); Py_CLEAR(clear_module_state->__pyx_kp_s_Incompatible_checksums_0x_x_vs_0); Py_CLEAR(clear_module_state->__pyx_n_s_IndexError); Py_CLEAR(clear_module_state->__pyx_kp_s_Index_out_of_bounds_axis_d); Py_CLEAR(clear_module_state->__pyx_kp_s_Indirect_dimensions_not_supporte); Py_CLEAR(clear_module_state->__pyx_kp_u_Invalid_mode_expected_c_or_fortr); Py_CLEAR(clear_module_state->__pyx_kp_u_Invalid_shape_in_axis); Py_CLEAR(clear_module_state->__pyx_kp_u_Iteration); Py_CLEAR(clear_module_state->__pyx_n_s_MemoryError); Py_CLEAR(clear_module_state->__pyx_kp_s_MemoryView_of_r_at_0x_x); Py_CLEAR(clear_module_state->__pyx_kp_s_MemoryView_of_r_object); Py_CLEAR(clear_module_state->__pyx_n_b_O); Py_CLEAR(clear_module_state->__pyx_kp_u_Out_of_bounds_on_buffer_access_a); Py_CLEAR(clear_module_state->__pyx_n_s_PickleError); Py_CLEAR(clear_module_state->__pyx_kp_u_Please_choose_a_supported_PSF_mo); Py_CLEAR(clear_module_state->__pyx_kp_u_Please_choose_a_valid_fine_struc); Py_CLEAR(clear_module_state->__pyx_n_s_Sequence); Py_CLEAR(clear_module_state->__pyx_kp_u_Starting_L_A_Cosmic_iterations); Py_CLEAR(clear_module_state->__pyx_kp_s_Step_may_not_be_zero_axis_d); Py_CLEAR(clear_module_state->__pyx_n_s_TypeError); Py_CLEAR(clear_module_state->__pyx_kp_s_Unable_to_convert_item_to_object); Py_CLEAR(clear_module_state->__pyx_n_s_ValueError); Py_CLEAR(clear_module_state->__pyx_n_s_View_MemoryView); Py_CLEAR(clear_module_state->__pyx_kp_u__2); Py_CLEAR(clear_module_state->__pyx_n_s__3); Py_CLEAR(clear_module_state->__pyx_n_s__38); Py_CLEAR(clear_module_state->__pyx_kp_u__6); Py_CLEAR(clear_module_state->__pyx_kp_u__7); Py_CLEAR(clear_module_state->__pyx_n_s_abc); Py_CLEAR(clear_module_state->__pyx_n_s_allocate_buffer); Py_CLEAR(clear_module_state->__pyx_kp_u_and); Py_CLEAR(clear_module_state->__pyx_n_s_arange); Py_CLEAR(clear_module_state->__pyx_n_s_array); Py_CLEAR(clear_module_state->__pyx_n_s_asarray); Py_CLEAR(clear_module_state->__pyx_n_s_astroscrappy_astroscrappy); Py_CLEAR(clear_module_state->__pyx_kp_s_astroscrappy_astroscrappy_pyx); Py_CLEAR(clear_module_state->__pyx_n_s_astype); Py_CLEAR(clear_module_state->__pyx_n_s_asyncio_coroutines); Py_CLEAR(clear_module_state->__pyx_n_s_background_level); Py_CLEAR(clear_module_state->__pyx_n_s_background_var_level); Py_CLEAR(clear_module_state->__pyx_n_s_base); Py_CLEAR(clear_module_state->__pyx_n_s_bkg); Py_CLEAR(clear_module_state->__pyx_n_s_bool); Py_CLEAR(clear_module_state->__pyx_n_s_c); Py_CLEAR(clear_module_state->__pyx_n_u_c); Py_CLEAR(clear_module_state->__pyx_n_s_class); Py_CLEAR(clear_module_state->__pyx_n_s_class_getitem); Py_CLEAR(clear_module_state->__pyx_n_s_clean_var); Py_CLEAR(clear_module_state->__pyx_n_s_cleanarr); Py_CLEAR(clear_module_state->__pyx_n_s_cleantype); Py_CLEAR(clear_module_state->__pyx_kp_u_cleantype_must_be_one_of_the_fol); Py_CLEAR(clear_module_state->__pyx_n_s_cline_in_traceback); Py_CLEAR(clear_module_state->__pyx_n_s_collections); Py_CLEAR(clear_module_state->__pyx_kp_s_collections_abc); Py_CLEAR(clear_module_state->__pyx_kp_s_contiguous_and_direct); Py_CLEAR(clear_module_state->__pyx_kp_s_contiguous_and_indirect); Py_CLEAR(clear_module_state->__pyx_n_s_conved); Py_CLEAR(clear_module_state->__pyx_n_s_convolve); Py_CLEAR(clear_module_state->__pyx_n_u_convolve); Py_CLEAR(clear_module_state->__pyx_n_s_copy); Py_CLEAR(clear_module_state->__pyx_kp_u_cosmic_pixels_this_iteration); Py_CLEAR(clear_module_state->__pyx_n_s_cosmics); Py_CLEAR(clear_module_state->__pyx_n_s_count); Py_CLEAR(clear_module_state->__pyx_n_s_crmask); Py_CLEAR(clear_module_state->__pyx_n_s_data); Py_CLEAR(clear_module_state->__pyx_n_s_detect_cosmics); Py_CLEAR(clear_module_state->__pyx_n_s_dict); Py_CLEAR(clear_module_state->__pyx_n_s_dilate3); Py_CLEAR(clear_module_state->__pyx_n_s_dilate5); Py_CLEAR(clear_module_state->__pyx_n_s_dilsatpixels); Py_CLEAR(clear_module_state->__pyx_kp_u_disable); Py_CLEAR(clear_module_state->__pyx_n_s_dtype); Py_CLEAR(clear_module_state->__pyx_n_s_dtype_is_object); Py_CLEAR(clear_module_state->__pyx_n_s_empty); Py_CLEAR(clear_module_state->__pyx_n_s_empty_like); Py_CLEAR(clear_module_state->__pyx_kp_u_enable); Py_CLEAR(clear_module_state->__pyx_n_s_encode); Py_CLEAR(clear_module_state->__pyx_n_s_enumerate); Py_CLEAR(clear_module_state->__pyx_n_s_error); Py_CLEAR(clear_module_state->__pyx_n_s_exp); Py_CLEAR(clear_module_state->__pyx_n_s_f); Py_CLEAR(clear_module_state->__pyx_n_s_flags); Py_CLEAR(clear_module_state->__pyx_n_s_float32); Py_CLEAR(clear_module_state->__pyx_n_s_format); Py_CLEAR(clear_module_state->__pyx_n_s_fortran); Py_CLEAR(clear_module_state->__pyx_n_u_fortran); Py_CLEAR(clear_module_state->__pyx_n_s_fsmode); Py_CLEAR(clear_module_state->__pyx_n_s_gain); Py_CLEAR(clear_module_state->__pyx_n_u_gauss); Py_CLEAR(clear_module_state->__pyx_n_s_gausskernel); Py_CLEAR(clear_module_state->__pyx_n_u_gaussx); Py_CLEAR(clear_module_state->__pyx_n_s_gaussxkernel); Py_CLEAR(clear_module_state->__pyx_n_u_gaussy); Py_CLEAR(clear_module_state->__pyx_n_s_gaussykernel); Py_CLEAR(clear_module_state->__pyx_kp_u_gc); Py_CLEAR(clear_module_state->__pyx_n_s_getstate); Py_CLEAR(clear_module_state->__pyx_n_s_gooddata); Py_CLEAR(clear_module_state->__pyx_n_s_goodpix); Py_CLEAR(clear_module_state->__pyx_n_s_goodvar); Py_CLEAR(clear_module_state->__pyx_kp_u_got); Py_CLEAR(clear_module_state->__pyx_kp_u_got_differing_extents_in_dimensi); Py_CLEAR(clear_module_state->__pyx_n_s_grow_mask); Py_CLEAR(clear_module_state->__pyx_n_s_i); Py_CLEAR(clear_module_state->__pyx_n_s_id); Py_CLEAR(clear_module_state->__pyx_n_u_idw); Py_CLEAR(clear_module_state->__pyx_n_s_igoodpix); Py_CLEAR(clear_module_state->__pyx_n_s_import); Py_CLEAR(clear_module_state->__pyx_n_s_inbkg); Py_CLEAR(clear_module_state->__pyx_n_s_indat); Py_CLEAR(clear_module_state->__pyx_n_s_index); Py_CLEAR(clear_module_state->__pyx_n_s_initializing); Py_CLEAR(clear_module_state->__pyx_n_s_inmask); Py_CLEAR(clear_module_state->__pyx_n_s_invar); Py_CLEAR(clear_module_state->__pyx_n_s_is_coroutine); Py_CLEAR(clear_module_state->__pyx_kp_u_isenabled); Py_CLEAR(clear_module_state->__pyx_n_s_itemsize); Py_CLEAR(clear_module_state->__pyx_kp_s_itemsize_0_for_cython_array); Py_CLEAR(clear_module_state->__pyx_n_s_j); Py_CLEAR(clear_module_state->__pyx_n_s_kernel); Py_CLEAR(clear_module_state->__pyx_n_s_kernsize); Py_CLEAR(clear_module_state->__pyx_n_s_laplaceconvolve); Py_CLEAR(clear_module_state->__pyx_n_s_logical_and); Py_CLEAR(clear_module_state->__pyx_n_s_logical_not); Py_CLEAR(clear_module_state->__pyx_n_s_logical_or); Py_CLEAR(clear_module_state->__pyx_n_s_m5); Py_CLEAR(clear_module_state->__pyx_n_s_m7); Py_CLEAR(clear_module_state->__pyx_n_s_main); Py_CLEAR(clear_module_state->__pyx_n_s_mask); Py_CLEAR(clear_module_state->__pyx_n_u_meanmask); Py_CLEAR(clear_module_state->__pyx_n_s_medfilt3); Py_CLEAR(clear_module_state->__pyx_n_s_medfilt5); Py_CLEAR(clear_module_state->__pyx_n_s_medfilt7); Py_CLEAR(clear_module_state->__pyx_n_s_median); Py_CLEAR(clear_module_state->__pyx_n_u_median); Py_CLEAR(clear_module_state->__pyx_n_u_medmask); Py_CLEAR(clear_module_state->__pyx_n_s_memview); Py_CLEAR(clear_module_state->__pyx_n_s_mode); Py_CLEAR(clear_module_state->__pyx_n_u_moffat); Py_CLEAR(clear_module_state->__pyx_n_s_name); Py_CLEAR(clear_module_state->__pyx_n_s_name_2); Py_CLEAR(clear_module_state->__pyx_n_s_ndim); Py_CLEAR(clear_module_state->__pyx_n_s_new); Py_CLEAR(clear_module_state->__pyx_n_s_niter); Py_CLEAR(clear_module_state->__pyx_kp_s_no_default___reduce___due_to_non); Py_CLEAR(clear_module_state->__pyx_n_s_noise); Py_CLEAR(clear_module_state->__pyx_n_s_np); Py_CLEAR(clear_module_state->__pyx_n_s_numcr); Py_CLEAR(clear_module_state->__pyx_n_s_numpy); Py_CLEAR(clear_module_state->__pyx_kp_u_numpy__core_multiarray_failed_to); Py_CLEAR(clear_module_state->__pyx_kp_u_numpy__core_umath_failed_to_impo); Py_CLEAR(clear_module_state->__pyx_n_s_nx); Py_CLEAR(clear_module_state->__pyx_n_s_ny); Py_CLEAR(clear_module_state->__pyx_n_s_obj); Py_CLEAR(clear_module_state->__pyx_n_s_objlim); Py_CLEAR(clear_module_state->__pyx_n_s_order); Py_CLEAR(clear_module_state->__pyx_n_s_pack); Py_CLEAR(clear_module_state->__pyx_n_s_pickle); Py_CLEAR(clear_module_state->__pyx_n_s_power); Py_CLEAR(clear_module_state->__pyx_n_s_print); Py_CLEAR(clear_module_state->__pyx_n_s_psfbeta); Py_CLEAR(clear_module_state->__pyx_n_s_psffwhm); Py_CLEAR(clear_module_state->__pyx_n_s_psfk); Py_CLEAR(clear_module_state->__pyx_n_s_psfmodel); Py_CLEAR(clear_module_state->__pyx_n_s_psfsize); Py_CLEAR(clear_module_state->__pyx_n_s_pyx_PickleError); Py_CLEAR(clear_module_state->__pyx_n_s_pyx_checksum); Py_CLEAR(clear_module_state->__pyx_n_s_pyx_result); Py_CLEAR(clear_module_state->__pyx_n_s_pyx_state); Py_CLEAR(clear_module_state->__pyx_n_s_pyx_type); Py_CLEAR(clear_module_state->__pyx_n_s_pyx_unpickle_Enum); Py_CLEAR(clear_module_state->__pyx_n_s_pyx_vtable); Py_CLEAR(clear_module_state->__pyx_n_s_r2); Py_CLEAR(clear_module_state->__pyx_n_s_range); Py_CLEAR(clear_module_state->__pyx_n_s_readnoise); Py_CLEAR(clear_module_state->__pyx_n_s_rebin); Py_CLEAR(clear_module_state->__pyx_n_s_reduce); Py_CLEAR(clear_module_state->__pyx_n_s_reduce_cython); Py_CLEAR(clear_module_state->__pyx_n_s_reduce_ex); Py_CLEAR(clear_module_state->__pyx_n_s_register); Py_CLEAR(clear_module_state->__pyx_n_s_s); Py_CLEAR(clear_module_state->__pyx_n_s_satlevel); Py_CLEAR(clear_module_state->__pyx_n_s_satpixels); Py_CLEAR(clear_module_state->__pyx_n_s_sepmed); Py_CLEAR(clear_module_state->__pyx_n_s_sepmedfilt5); Py_CLEAR(clear_module_state->__pyx_n_s_sepmedfilt7); Py_CLEAR(clear_module_state->__pyx_n_s_sepmedfilt9); Py_CLEAR(clear_module_state->__pyx_n_s_setstate); Py_CLEAR(clear_module_state->__pyx_n_s_setstate_cython); Py_CLEAR(clear_module_state->__pyx_n_s_shape); Py_CLEAR(clear_module_state->__pyx_n_s_sigclip); Py_CLEAR(clear_module_state->__pyx_n_s_sigcliplow); Py_CLEAR(clear_module_state->__pyx_n_s_sigfrac); Py_CLEAR(clear_module_state->__pyx_n_s_sigma2); Py_CLEAR(clear_module_state->__pyx_n_s_size); Py_CLEAR(clear_module_state->__pyx_n_s_sp); Py_CLEAR(clear_module_state->__pyx_n_s_spec); Py_CLEAR(clear_module_state->__pyx_n_s_sqrt); Py_CLEAR(clear_module_state->__pyx_n_s_start); Py_CLEAR(clear_module_state->__pyx_n_s_step); Py_CLEAR(clear_module_state->__pyx_n_s_stop); Py_CLEAR(clear_module_state->__pyx_kp_s_strided_and_direct); Py_CLEAR(clear_module_state->__pyx_kp_s_strided_and_direct_or_indirect); Py_CLEAR(clear_module_state->__pyx_kp_s_strided_and_indirect); Py_CLEAR(clear_module_state->__pyx_kp_s_stringsource); Py_CLEAR(clear_module_state->__pyx_n_s_struct); Py_CLEAR(clear_module_state->__pyx_n_s_subsam); Py_CLEAR(clear_module_state->__pyx_n_s_subsample); Py_CLEAR(clear_module_state->__pyx_n_s_sum); Py_CLEAR(clear_module_state->__pyx_n_s_sys); Py_CLEAR(clear_module_state->__pyx_n_s_test); Py_CLEAR(clear_module_state->__pyx_n_s_tile); Py_CLEAR(clear_module_state->__pyx_n_s_transpose); Py_CLEAR(clear_module_state->__pyx_n_s_uint8); Py_CLEAR(clear_module_state->__pyx_kp_s_unable_to_allocate_array_data); Py_CLEAR(clear_module_state->__pyx_kp_s_unable_to_allocate_shape_and_str); Py_CLEAR(clear_module_state->__pyx_n_s_unpack); Py_CLEAR(clear_module_state->__pyx_n_s_update); Py_CLEAR(clear_module_state->__pyx_n_s_update_mask); Py_CLEAR(clear_module_state->__pyx_n_s_utils); Py_CLEAR(clear_module_state->__pyx_n_s_verbose); Py_CLEAR(clear_module_state->__pyx_n_s_version_info); Py_CLEAR(clear_module_state->__pyx_n_s_x); Py_CLEAR(clear_module_state->__pyx_n_s_y); Py_CLEAR(clear_module_state->__pyx_n_s_zeros); Py_CLEAR(clear_module_state->__pyx_float_0_); Py_CLEAR(clear_module_state->__pyx_float_1_); Py_CLEAR(clear_module_state->__pyx_float_0_0); Py_CLEAR(clear_module_state->__pyx_float_0_5); Py_CLEAR(clear_module_state->__pyx_float_1_0); Py_CLEAR(clear_module_state->__pyx_float_2_0); Py_CLEAR(clear_module_state->__pyx_float_0_01); Py_CLEAR(clear_module_state->__pyx_float_0_00001); Py_CLEAR(clear_module_state->__pyx_float_0_4472136); Py_CLEAR(clear_module_state->__pyx_float_0_35355339); Py_CLEAR(clear_module_state->__pyx_float_0_70710678); Py_CLEAR(clear_module_state->__pyx_float_neg_0_5); Py_CLEAR(clear_module_state->__pyx_int_0); Py_CLEAR(clear_module_state->__pyx_int_1); Py_CLEAR(clear_module_state->__pyx_int_2); Py_CLEAR(clear_module_state->__pyx_int_3); Py_CLEAR(clear_module_state->__pyx_int_112105877); Py_CLEAR(clear_module_state->__pyx_int_136983863); Py_CLEAR(clear_module_state->__pyx_int_184977713); Py_CLEAR(clear_module_state->__pyx_int_neg_1); Py_CLEAR(clear_module_state->__pyx_slice__5); Py_CLEAR(clear_module_state->__pyx_tuple__4); Py_CLEAR(clear_module_state->__pyx_tuple__8); Py_CLEAR(clear_module_state->__pyx_tuple__9); Py_CLEAR(clear_module_state->__pyx_slice__13); Py_CLEAR(clear_module_state->__pyx_tuple__10); Py_CLEAR(clear_module_state->__pyx_tuple__11); Py_CLEAR(clear_module_state->__pyx_tuple__12); Py_CLEAR(clear_module_state->__pyx_tuple__14); Py_CLEAR(clear_module_state->__pyx_tuple__15); Py_CLEAR(clear_module_state->__pyx_tuple__16); Py_CLEAR(clear_module_state->__pyx_tuple__17); Py_CLEAR(clear_module_state->__pyx_tuple__18); Py_CLEAR(clear_module_state->__pyx_tuple__19); Py_CLEAR(clear_module_state->__pyx_tuple__20); Py_CLEAR(clear_module_state->__pyx_tuple__21); Py_CLEAR(clear_module_state->__pyx_tuple__22); Py_CLEAR(clear_module_state->__pyx_tuple__23); Py_CLEAR(clear_module_state->__pyx_tuple__24); Py_CLEAR(clear_module_state->__pyx_tuple__25); Py_CLEAR(clear_module_state->__pyx_tuple__26); Py_CLEAR(clear_module_state->__pyx_tuple__28); Py_CLEAR(clear_module_state->__pyx_tuple__30); Py_CLEAR(clear_module_state->__pyx_tuple__32); Py_CLEAR(clear_module_state->__pyx_tuple__34); Py_CLEAR(clear_module_state->__pyx_tuple__36); Py_CLEAR(clear_module_state->__pyx_codeobj__27); Py_CLEAR(clear_module_state->__pyx_codeobj__29); Py_CLEAR(clear_module_state->__pyx_codeobj__31); Py_CLEAR(clear_module_state->__pyx_codeobj__33); Py_CLEAR(clear_module_state->__pyx_codeobj__35); Py_CLEAR(clear_module_state->__pyx_codeobj__37); return 0; } #endif /* #### Code section: module_state_traverse ### */ #if CYTHON_USE_MODULE_STATE static int __pyx_m_traverse(PyObject *m, visitproc visit, void *arg) { __pyx_mstate *traverse_module_state = __pyx_mstate(m); if (!traverse_module_state) return 0; Py_VISIT(traverse_module_state->__pyx_d); Py_VISIT(traverse_module_state->__pyx_b); Py_VISIT(traverse_module_state->__pyx_cython_runtime); Py_VISIT(traverse_module_state->__pyx_empty_tuple); Py_VISIT(traverse_module_state->__pyx_empty_bytes); Py_VISIT(traverse_module_state->__pyx_empty_unicode); #ifdef __Pyx_CyFunction_USED Py_VISIT(traverse_module_state->__pyx_CyFunctionType); #endif #ifdef __Pyx_FusedFunction_USED Py_VISIT(traverse_module_state->__pyx_FusedFunctionType); #endif Py_VISIT(traverse_module_state->__pyx_ptype_7cpython_4type_type); Py_VISIT(traverse_module_state->__pyx_ptype_5numpy_dtype); Py_VISIT(traverse_module_state->__pyx_ptype_5numpy_flatiter); Py_VISIT(traverse_module_state->__pyx_ptype_5numpy_broadcast); Py_VISIT(traverse_module_state->__pyx_ptype_5numpy_ndarray); Py_VISIT(traverse_module_state->__pyx_ptype_5numpy_generic); Py_VISIT(traverse_module_state->__pyx_ptype_5numpy_number); Py_VISIT(traverse_module_state->__pyx_ptype_5numpy_integer); Py_VISIT(traverse_module_state->__pyx_ptype_5numpy_signedinteger); Py_VISIT(traverse_module_state->__pyx_ptype_5numpy_unsignedinteger); Py_VISIT(traverse_module_state->__pyx_ptype_5numpy_inexact); Py_VISIT(traverse_module_state->__pyx_ptype_5numpy_floating); Py_VISIT(traverse_module_state->__pyx_ptype_5numpy_complexfloating); Py_VISIT(traverse_module_state->__pyx_ptype_5numpy_flexible); Py_VISIT(traverse_module_state->__pyx_ptype_5numpy_character); Py_VISIT(traverse_module_state->__pyx_ptype_5numpy_ufunc); Py_VISIT(traverse_module_state->__pyx_array_type); Py_VISIT(traverse_module_state->__pyx_type___pyx_array); Py_VISIT(traverse_module_state->__pyx_MemviewEnum_type); Py_VISIT(traverse_module_state->__pyx_type___pyx_MemviewEnum); Py_VISIT(traverse_module_state->__pyx_memoryview_type); Py_VISIT(traverse_module_state->__pyx_type___pyx_memoryview); Py_VISIT(traverse_module_state->__pyx_memoryviewslice_type); Py_VISIT(traverse_module_state->__pyx_type___pyx_memoryviewslice); Py_VISIT(traverse_module_state->__pyx_kp_u_); Py_VISIT(traverse_module_state->__pyx_n_s_ASCII); Py_VISIT(traverse_module_state->__pyx_kp_s_All_dimensions_preceding_dimensi); Py_VISIT(traverse_module_state->__pyx_n_s_AssertionError); Py_VISIT(traverse_module_state->__pyx_kp_s_Buffer_view_does_not_expose_stri); Py_VISIT(traverse_module_state->__pyx_n_u_C); Py_VISIT(traverse_module_state->__pyx_kp_s_Can_only_create_a_buffer_that_is); Py_VISIT(traverse_module_state->__pyx_kp_s_Cannot_assign_to_read_only_memor); Py_VISIT(traverse_module_state->__pyx_kp_s_Cannot_create_writable_memory_vi); Py_VISIT(traverse_module_state->__pyx_kp_u_Cannot_index_with_type); Py_VISIT(traverse_module_state->__pyx_kp_s_Cannot_transpose_memoryview_with); Py_VISIT(traverse_module_state->__pyx_kp_s_Dimension_d_is_not_direct); Py_VISIT(traverse_module_state->__pyx_n_s_Ellipsis); Py_VISIT(traverse_module_state->__pyx_kp_s_Empty_shape_tuple_for_cython_arr); Py_VISIT(traverse_module_state->__pyx_n_s_ImportError); Py_VISIT(traverse_module_state->__pyx_kp_s_Incompatible_checksums_0x_x_vs_0); Py_VISIT(traverse_module_state->__pyx_n_s_IndexError); Py_VISIT(traverse_module_state->__pyx_kp_s_Index_out_of_bounds_axis_d); Py_VISIT(traverse_module_state->__pyx_kp_s_Indirect_dimensions_not_supporte); Py_VISIT(traverse_module_state->__pyx_kp_u_Invalid_mode_expected_c_or_fortr); Py_VISIT(traverse_module_state->__pyx_kp_u_Invalid_shape_in_axis); Py_VISIT(traverse_module_state->__pyx_kp_u_Iteration); Py_VISIT(traverse_module_state->__pyx_n_s_MemoryError); Py_VISIT(traverse_module_state->__pyx_kp_s_MemoryView_of_r_at_0x_x); Py_VISIT(traverse_module_state->__pyx_kp_s_MemoryView_of_r_object); Py_VISIT(traverse_module_state->__pyx_n_b_O); Py_VISIT(traverse_module_state->__pyx_kp_u_Out_of_bounds_on_buffer_access_a); Py_VISIT(traverse_module_state->__pyx_n_s_PickleError); Py_VISIT(traverse_module_state->__pyx_kp_u_Please_choose_a_supported_PSF_mo); Py_VISIT(traverse_module_state->__pyx_kp_u_Please_choose_a_valid_fine_struc); Py_VISIT(traverse_module_state->__pyx_n_s_Sequence); Py_VISIT(traverse_module_state->__pyx_kp_u_Starting_L_A_Cosmic_iterations); Py_VISIT(traverse_module_state->__pyx_kp_s_Step_may_not_be_zero_axis_d); Py_VISIT(traverse_module_state->__pyx_n_s_TypeError); Py_VISIT(traverse_module_state->__pyx_kp_s_Unable_to_convert_item_to_object); Py_VISIT(traverse_module_state->__pyx_n_s_ValueError); Py_VISIT(traverse_module_state->__pyx_n_s_View_MemoryView); Py_VISIT(traverse_module_state->__pyx_kp_u__2); Py_VISIT(traverse_module_state->__pyx_n_s__3); Py_VISIT(traverse_module_state->__pyx_n_s__38); Py_VISIT(traverse_module_state->__pyx_kp_u__6); Py_VISIT(traverse_module_state->__pyx_kp_u__7); Py_VISIT(traverse_module_state->__pyx_n_s_abc); Py_VISIT(traverse_module_state->__pyx_n_s_allocate_buffer); Py_VISIT(traverse_module_state->__pyx_kp_u_and); Py_VISIT(traverse_module_state->__pyx_n_s_arange); Py_VISIT(traverse_module_state->__pyx_n_s_array); Py_VISIT(traverse_module_state->__pyx_n_s_asarray); Py_VISIT(traverse_module_state->__pyx_n_s_astroscrappy_astroscrappy); Py_VISIT(traverse_module_state->__pyx_kp_s_astroscrappy_astroscrappy_pyx); Py_VISIT(traverse_module_state->__pyx_n_s_astype); Py_VISIT(traverse_module_state->__pyx_n_s_asyncio_coroutines); Py_VISIT(traverse_module_state->__pyx_n_s_background_level); Py_VISIT(traverse_module_state->__pyx_n_s_background_var_level); Py_VISIT(traverse_module_state->__pyx_n_s_base); Py_VISIT(traverse_module_state->__pyx_n_s_bkg); Py_VISIT(traverse_module_state->__pyx_n_s_bool); Py_VISIT(traverse_module_state->__pyx_n_s_c); Py_VISIT(traverse_module_state->__pyx_n_u_c); Py_VISIT(traverse_module_state->__pyx_n_s_class); Py_VISIT(traverse_module_state->__pyx_n_s_class_getitem); Py_VISIT(traverse_module_state->__pyx_n_s_clean_var); Py_VISIT(traverse_module_state->__pyx_n_s_cleanarr); Py_VISIT(traverse_module_state->__pyx_n_s_cleantype); Py_VISIT(traverse_module_state->__pyx_kp_u_cleantype_must_be_one_of_the_fol); Py_VISIT(traverse_module_state->__pyx_n_s_cline_in_traceback); Py_VISIT(traverse_module_state->__pyx_n_s_collections); Py_VISIT(traverse_module_state->__pyx_kp_s_collections_abc); Py_VISIT(traverse_module_state->__pyx_kp_s_contiguous_and_direct); Py_VISIT(traverse_module_state->__pyx_kp_s_contiguous_and_indirect); Py_VISIT(traverse_module_state->__pyx_n_s_conved); Py_VISIT(traverse_module_state->__pyx_n_s_convolve); Py_VISIT(traverse_module_state->__pyx_n_u_convolve); Py_VISIT(traverse_module_state->__pyx_n_s_copy); Py_VISIT(traverse_module_state->__pyx_kp_u_cosmic_pixels_this_iteration); Py_VISIT(traverse_module_state->__pyx_n_s_cosmics); Py_VISIT(traverse_module_state->__pyx_n_s_count); Py_VISIT(traverse_module_state->__pyx_n_s_crmask); Py_VISIT(traverse_module_state->__pyx_n_s_data); Py_VISIT(traverse_module_state->__pyx_n_s_detect_cosmics); Py_VISIT(traverse_module_state->__pyx_n_s_dict); Py_VISIT(traverse_module_state->__pyx_n_s_dilate3); Py_VISIT(traverse_module_state->__pyx_n_s_dilate5); Py_VISIT(traverse_module_state->__pyx_n_s_dilsatpixels); Py_VISIT(traverse_module_state->__pyx_kp_u_disable); Py_VISIT(traverse_module_state->__pyx_n_s_dtype); Py_VISIT(traverse_module_state->__pyx_n_s_dtype_is_object); Py_VISIT(traverse_module_state->__pyx_n_s_empty); Py_VISIT(traverse_module_state->__pyx_n_s_empty_like); Py_VISIT(traverse_module_state->__pyx_kp_u_enable); Py_VISIT(traverse_module_state->__pyx_n_s_encode); Py_VISIT(traverse_module_state->__pyx_n_s_enumerate); Py_VISIT(traverse_module_state->__pyx_n_s_error); Py_VISIT(traverse_module_state->__pyx_n_s_exp); Py_VISIT(traverse_module_state->__pyx_n_s_f); Py_VISIT(traverse_module_state->__pyx_n_s_flags); Py_VISIT(traverse_module_state->__pyx_n_s_float32); Py_VISIT(traverse_module_state->__pyx_n_s_format); Py_VISIT(traverse_module_state->__pyx_n_s_fortran); Py_VISIT(traverse_module_state->__pyx_n_u_fortran); Py_VISIT(traverse_module_state->__pyx_n_s_fsmode); Py_VISIT(traverse_module_state->__pyx_n_s_gain); Py_VISIT(traverse_module_state->__pyx_n_u_gauss); Py_VISIT(traverse_module_state->__pyx_n_s_gausskernel); Py_VISIT(traverse_module_state->__pyx_n_u_gaussx); Py_VISIT(traverse_module_state->__pyx_n_s_gaussxkernel); Py_VISIT(traverse_module_state->__pyx_n_u_gaussy); Py_VISIT(traverse_module_state->__pyx_n_s_gaussykernel); Py_VISIT(traverse_module_state->__pyx_kp_u_gc); Py_VISIT(traverse_module_state->__pyx_n_s_getstate); Py_VISIT(traverse_module_state->__pyx_n_s_gooddata); Py_VISIT(traverse_module_state->__pyx_n_s_goodpix); Py_VISIT(traverse_module_state->__pyx_n_s_goodvar); Py_VISIT(traverse_module_state->__pyx_kp_u_got); Py_VISIT(traverse_module_state->__pyx_kp_u_got_differing_extents_in_dimensi); Py_VISIT(traverse_module_state->__pyx_n_s_grow_mask); Py_VISIT(traverse_module_state->__pyx_n_s_i); Py_VISIT(traverse_module_state->__pyx_n_s_id); Py_VISIT(traverse_module_state->__pyx_n_u_idw); Py_VISIT(traverse_module_state->__pyx_n_s_igoodpix); Py_VISIT(traverse_module_state->__pyx_n_s_import); Py_VISIT(traverse_module_state->__pyx_n_s_inbkg); Py_VISIT(traverse_module_state->__pyx_n_s_indat); Py_VISIT(traverse_module_state->__pyx_n_s_index); Py_VISIT(traverse_module_state->__pyx_n_s_initializing); Py_VISIT(traverse_module_state->__pyx_n_s_inmask); Py_VISIT(traverse_module_state->__pyx_n_s_invar); Py_VISIT(traverse_module_state->__pyx_n_s_is_coroutine); Py_VISIT(traverse_module_state->__pyx_kp_u_isenabled); Py_VISIT(traverse_module_state->__pyx_n_s_itemsize); Py_VISIT(traverse_module_state->__pyx_kp_s_itemsize_0_for_cython_array); Py_VISIT(traverse_module_state->__pyx_n_s_j); Py_VISIT(traverse_module_state->__pyx_n_s_kernel); Py_VISIT(traverse_module_state->__pyx_n_s_kernsize); Py_VISIT(traverse_module_state->__pyx_n_s_laplaceconvolve); Py_VISIT(traverse_module_state->__pyx_n_s_logical_and); Py_VISIT(traverse_module_state->__pyx_n_s_logical_not); Py_VISIT(traverse_module_state->__pyx_n_s_logical_or); Py_VISIT(traverse_module_state->__pyx_n_s_m5); Py_VISIT(traverse_module_state->__pyx_n_s_m7); Py_VISIT(traverse_module_state->__pyx_n_s_main); Py_VISIT(traverse_module_state->__pyx_n_s_mask); Py_VISIT(traverse_module_state->__pyx_n_u_meanmask); Py_VISIT(traverse_module_state->__pyx_n_s_medfilt3); Py_VISIT(traverse_module_state->__pyx_n_s_medfilt5); Py_VISIT(traverse_module_state->__pyx_n_s_medfilt7); Py_VISIT(traverse_module_state->__pyx_n_s_median); Py_VISIT(traverse_module_state->__pyx_n_u_median); Py_VISIT(traverse_module_state->__pyx_n_u_medmask); Py_VISIT(traverse_module_state->__pyx_n_s_memview); Py_VISIT(traverse_module_state->__pyx_n_s_mode); Py_VISIT(traverse_module_state->__pyx_n_u_moffat); Py_VISIT(traverse_module_state->__pyx_n_s_name); Py_VISIT(traverse_module_state->__pyx_n_s_name_2); Py_VISIT(traverse_module_state->__pyx_n_s_ndim); Py_VISIT(traverse_module_state->__pyx_n_s_new); Py_VISIT(traverse_module_state->__pyx_n_s_niter); Py_VISIT(traverse_module_state->__pyx_kp_s_no_default___reduce___due_to_non); Py_VISIT(traverse_module_state->__pyx_n_s_noise); Py_VISIT(traverse_module_state->__pyx_n_s_np); Py_VISIT(traverse_module_state->__pyx_n_s_numcr); Py_VISIT(traverse_module_state->__pyx_n_s_numpy); Py_VISIT(traverse_module_state->__pyx_kp_u_numpy__core_multiarray_failed_to); Py_VISIT(traverse_module_state->__pyx_kp_u_numpy__core_umath_failed_to_impo); Py_VISIT(traverse_module_state->__pyx_n_s_nx); Py_VISIT(traverse_module_state->__pyx_n_s_ny); Py_VISIT(traverse_module_state->__pyx_n_s_obj); Py_VISIT(traverse_module_state->__pyx_n_s_objlim); Py_VISIT(traverse_module_state->__pyx_n_s_order); Py_VISIT(traverse_module_state->__pyx_n_s_pack); Py_VISIT(traverse_module_state->__pyx_n_s_pickle); Py_VISIT(traverse_module_state->__pyx_n_s_power); Py_VISIT(traverse_module_state->__pyx_n_s_print); Py_VISIT(traverse_module_state->__pyx_n_s_psfbeta); Py_VISIT(traverse_module_state->__pyx_n_s_psffwhm); Py_VISIT(traverse_module_state->__pyx_n_s_psfk); Py_VISIT(traverse_module_state->__pyx_n_s_psfmodel); Py_VISIT(traverse_module_state->__pyx_n_s_psfsize); Py_VISIT(traverse_module_state->__pyx_n_s_pyx_PickleError); Py_VISIT(traverse_module_state->__pyx_n_s_pyx_checksum); Py_VISIT(traverse_module_state->__pyx_n_s_pyx_result); Py_VISIT(traverse_module_state->__pyx_n_s_pyx_state); Py_VISIT(traverse_module_state->__pyx_n_s_pyx_type); Py_VISIT(traverse_module_state->__pyx_n_s_pyx_unpickle_Enum); Py_VISIT(traverse_module_state->__pyx_n_s_pyx_vtable); Py_VISIT(traverse_module_state->__pyx_n_s_r2); Py_VISIT(traverse_module_state->__pyx_n_s_range); Py_VISIT(traverse_module_state->__pyx_n_s_readnoise); Py_VISIT(traverse_module_state->__pyx_n_s_rebin); Py_VISIT(traverse_module_state->__pyx_n_s_reduce); Py_VISIT(traverse_module_state->__pyx_n_s_reduce_cython); Py_VISIT(traverse_module_state->__pyx_n_s_reduce_ex); Py_VISIT(traverse_module_state->__pyx_n_s_register); Py_VISIT(traverse_module_state->__pyx_n_s_s); Py_VISIT(traverse_module_state->__pyx_n_s_satlevel); Py_VISIT(traverse_module_state->__pyx_n_s_satpixels); Py_VISIT(traverse_module_state->__pyx_n_s_sepmed); Py_VISIT(traverse_module_state->__pyx_n_s_sepmedfilt5); Py_VISIT(traverse_module_state->__pyx_n_s_sepmedfilt7); Py_VISIT(traverse_module_state->__pyx_n_s_sepmedfilt9); Py_VISIT(traverse_module_state->__pyx_n_s_setstate); Py_VISIT(traverse_module_state->__pyx_n_s_setstate_cython); Py_VISIT(traverse_module_state->__pyx_n_s_shape); Py_VISIT(traverse_module_state->__pyx_n_s_sigclip); Py_VISIT(traverse_module_state->__pyx_n_s_sigcliplow); Py_VISIT(traverse_module_state->__pyx_n_s_sigfrac); Py_VISIT(traverse_module_state->__pyx_n_s_sigma2); Py_VISIT(traverse_module_state->__pyx_n_s_size); Py_VISIT(traverse_module_state->__pyx_n_s_sp); Py_VISIT(traverse_module_state->__pyx_n_s_spec); Py_VISIT(traverse_module_state->__pyx_n_s_sqrt); Py_VISIT(traverse_module_state->__pyx_n_s_start); Py_VISIT(traverse_module_state->__pyx_n_s_step); Py_VISIT(traverse_module_state->__pyx_n_s_stop); Py_VISIT(traverse_module_state->__pyx_kp_s_strided_and_direct); Py_VISIT(traverse_module_state->__pyx_kp_s_strided_and_direct_or_indirect); Py_VISIT(traverse_module_state->__pyx_kp_s_strided_and_indirect); Py_VISIT(traverse_module_state->__pyx_kp_s_stringsource); Py_VISIT(traverse_module_state->__pyx_n_s_struct); Py_VISIT(traverse_module_state->__pyx_n_s_subsam); Py_VISIT(traverse_module_state->__pyx_n_s_subsample); Py_VISIT(traverse_module_state->__pyx_n_s_sum); Py_VISIT(traverse_module_state->__pyx_n_s_sys); Py_VISIT(traverse_module_state->__pyx_n_s_test); Py_VISIT(traverse_module_state->__pyx_n_s_tile); Py_VISIT(traverse_module_state->__pyx_n_s_transpose); Py_VISIT(traverse_module_state->__pyx_n_s_uint8); Py_VISIT(traverse_module_state->__pyx_kp_s_unable_to_allocate_array_data); Py_VISIT(traverse_module_state->__pyx_kp_s_unable_to_allocate_shape_and_str); Py_VISIT(traverse_module_state->__pyx_n_s_unpack); Py_VISIT(traverse_module_state->__pyx_n_s_update); Py_VISIT(traverse_module_state->__pyx_n_s_update_mask); Py_VISIT(traverse_module_state->__pyx_n_s_utils); Py_VISIT(traverse_module_state->__pyx_n_s_verbose); Py_VISIT(traverse_module_state->__pyx_n_s_version_info); Py_VISIT(traverse_module_state->__pyx_n_s_x); Py_VISIT(traverse_module_state->__pyx_n_s_y); Py_VISIT(traverse_module_state->__pyx_n_s_zeros); Py_VISIT(traverse_module_state->__pyx_float_0_); Py_VISIT(traverse_module_state->__pyx_float_1_); Py_VISIT(traverse_module_state->__pyx_float_0_0); Py_VISIT(traverse_module_state->__pyx_float_0_5); Py_VISIT(traverse_module_state->__pyx_float_1_0); Py_VISIT(traverse_module_state->__pyx_float_2_0); Py_VISIT(traverse_module_state->__pyx_float_0_01); Py_VISIT(traverse_module_state->__pyx_float_0_00001); Py_VISIT(traverse_module_state->__pyx_float_0_4472136); Py_VISIT(traverse_module_state->__pyx_float_0_35355339); Py_VISIT(traverse_module_state->__pyx_float_0_70710678); Py_VISIT(traverse_module_state->__pyx_float_neg_0_5); Py_VISIT(traverse_module_state->__pyx_int_0); Py_VISIT(traverse_module_state->__pyx_int_1); Py_VISIT(traverse_module_state->__pyx_int_2); Py_VISIT(traverse_module_state->__pyx_int_3); Py_VISIT(traverse_module_state->__pyx_int_112105877); Py_VISIT(traverse_module_state->__pyx_int_136983863); Py_VISIT(traverse_module_state->__pyx_int_184977713); Py_VISIT(traverse_module_state->__pyx_int_neg_1); Py_VISIT(traverse_module_state->__pyx_slice__5); Py_VISIT(traverse_module_state->__pyx_tuple__4); Py_VISIT(traverse_module_state->__pyx_tuple__8); Py_VISIT(traverse_module_state->__pyx_tuple__9); Py_VISIT(traverse_module_state->__pyx_slice__13); Py_VISIT(traverse_module_state->__pyx_tuple__10); Py_VISIT(traverse_module_state->__pyx_tuple__11); Py_VISIT(traverse_module_state->__pyx_tuple__12); Py_VISIT(traverse_module_state->__pyx_tuple__14); Py_VISIT(traverse_module_state->__pyx_tuple__15); Py_VISIT(traverse_module_state->__pyx_tuple__16); Py_VISIT(traverse_module_state->__pyx_tuple__17); Py_VISIT(traverse_module_state->__pyx_tuple__18); Py_VISIT(traverse_module_state->__pyx_tuple__19); Py_VISIT(traverse_module_state->__pyx_tuple__20); Py_VISIT(traverse_module_state->__pyx_tuple__21); Py_VISIT(traverse_module_state->__pyx_tuple__22); Py_VISIT(traverse_module_state->__pyx_tuple__23); Py_VISIT(traverse_module_state->__pyx_tuple__24); Py_VISIT(traverse_module_state->__pyx_tuple__25); Py_VISIT(traverse_module_state->__pyx_tuple__26); Py_VISIT(traverse_module_state->__pyx_tuple__28); Py_VISIT(traverse_module_state->__pyx_tuple__30); Py_VISIT(traverse_module_state->__pyx_tuple__32); Py_VISIT(traverse_module_state->__pyx_tuple__34); Py_VISIT(traverse_module_state->__pyx_tuple__36); Py_VISIT(traverse_module_state->__pyx_codeobj__27); Py_VISIT(traverse_module_state->__pyx_codeobj__29); Py_VISIT(traverse_module_state->__pyx_codeobj__31); Py_VISIT(traverse_module_state->__pyx_codeobj__33); Py_VISIT(traverse_module_state->__pyx_codeobj__35); Py_VISIT(traverse_module_state->__pyx_codeobj__37); return 0; } #endif /* #### Code section: module_state_defines ### */ #define __pyx_d __pyx_mstate_global->__pyx_d #define __pyx_b __pyx_mstate_global->__pyx_b #define __pyx_cython_runtime __pyx_mstate_global->__pyx_cython_runtime #define __pyx_empty_tuple __pyx_mstate_global->__pyx_empty_tuple #define __pyx_empty_bytes __pyx_mstate_global->__pyx_empty_bytes #define __pyx_empty_unicode __pyx_mstate_global->__pyx_empty_unicode #ifdef __Pyx_CyFunction_USED #define __pyx_CyFunctionType __pyx_mstate_global->__pyx_CyFunctionType #endif #ifdef __Pyx_FusedFunction_USED #define __pyx_FusedFunctionType __pyx_mstate_global->__pyx_FusedFunctionType #endif #ifdef __Pyx_Generator_USED #define __pyx_GeneratorType __pyx_mstate_global->__pyx_GeneratorType #endif #ifdef __Pyx_IterableCoroutine_USED #define __pyx_IterableCoroutineType __pyx_mstate_global->__pyx_IterableCoroutineType #endif #ifdef __Pyx_Coroutine_USED #define __pyx_CoroutineAwaitType __pyx_mstate_global->__pyx_CoroutineAwaitType #endif #ifdef __Pyx_Coroutine_USED #define __pyx_CoroutineType __pyx_mstate_global->__pyx_CoroutineType #endif #if CYTHON_USE_MODULE_STATE #endif #if CYTHON_USE_MODULE_STATE #endif #if CYTHON_USE_MODULE_STATE #endif #if CYTHON_USE_MODULE_STATE #endif #define __pyx_ptype_7cpython_4type_type __pyx_mstate_global->__pyx_ptype_7cpython_4type_type #if CYTHON_USE_MODULE_STATE #endif #if CYTHON_USE_MODULE_STATE #endif #if CYTHON_USE_MODULE_STATE #endif #if CYTHON_USE_MODULE_STATE #endif #if CYTHON_USE_MODULE_STATE #endif #define __pyx_ptype_5numpy_dtype __pyx_mstate_global->__pyx_ptype_5numpy_dtype #define __pyx_ptype_5numpy_flatiter __pyx_mstate_global->__pyx_ptype_5numpy_flatiter #define __pyx_ptype_5numpy_broadcast __pyx_mstate_global->__pyx_ptype_5numpy_broadcast #define __pyx_ptype_5numpy_ndarray __pyx_mstate_global->__pyx_ptype_5numpy_ndarray #define __pyx_ptype_5numpy_generic __pyx_mstate_global->__pyx_ptype_5numpy_generic #define __pyx_ptype_5numpy_number __pyx_mstate_global->__pyx_ptype_5numpy_number #define __pyx_ptype_5numpy_integer __pyx_mstate_global->__pyx_ptype_5numpy_integer #define __pyx_ptype_5numpy_signedinteger __pyx_mstate_global->__pyx_ptype_5numpy_signedinteger #define __pyx_ptype_5numpy_unsignedinteger __pyx_mstate_global->__pyx_ptype_5numpy_unsignedinteger #define __pyx_ptype_5numpy_inexact __pyx_mstate_global->__pyx_ptype_5numpy_inexact #define __pyx_ptype_5numpy_floating __pyx_mstate_global->__pyx_ptype_5numpy_floating #define __pyx_ptype_5numpy_complexfloating __pyx_mstate_global->__pyx_ptype_5numpy_complexfloating #define __pyx_ptype_5numpy_flexible __pyx_mstate_global->__pyx_ptype_5numpy_flexible #define __pyx_ptype_5numpy_character __pyx_mstate_global->__pyx_ptype_5numpy_character #define __pyx_ptype_5numpy_ufunc __pyx_mstate_global->__pyx_ptype_5numpy_ufunc #if CYTHON_USE_MODULE_STATE #endif #if CYTHON_USE_MODULE_STATE #endif #if CYTHON_USE_MODULE_STATE #endif #if CYTHON_USE_MODULE_STATE #endif #if CYTHON_USE_MODULE_STATE #endif #if CYTHON_USE_MODULE_STATE #endif #if CYTHON_USE_MODULE_STATE #define __pyx_type___pyx_array __pyx_mstate_global->__pyx_type___pyx_array #define __pyx_type___pyx_MemviewEnum __pyx_mstate_global->__pyx_type___pyx_MemviewEnum #define __pyx_type___pyx_memoryview __pyx_mstate_global->__pyx_type___pyx_memoryview #define __pyx_type___pyx_memoryviewslice __pyx_mstate_global->__pyx_type___pyx_memoryviewslice #endif #define __pyx_array_type __pyx_mstate_global->__pyx_array_type #define __pyx_MemviewEnum_type __pyx_mstate_global->__pyx_MemviewEnum_type #define __pyx_memoryview_type __pyx_mstate_global->__pyx_memoryview_type #define __pyx_memoryviewslice_type __pyx_mstate_global->__pyx_memoryviewslice_type #define __pyx_kp_u_ __pyx_mstate_global->__pyx_kp_u_ #define __pyx_n_s_ASCII __pyx_mstate_global->__pyx_n_s_ASCII #define __pyx_kp_s_All_dimensions_preceding_dimensi __pyx_mstate_global->__pyx_kp_s_All_dimensions_preceding_dimensi #define __pyx_n_s_AssertionError __pyx_mstate_global->__pyx_n_s_AssertionError #define __pyx_kp_s_Buffer_view_does_not_expose_stri __pyx_mstate_global->__pyx_kp_s_Buffer_view_does_not_expose_stri #define __pyx_n_u_C __pyx_mstate_global->__pyx_n_u_C #define __pyx_kp_s_Can_only_create_a_buffer_that_is __pyx_mstate_global->__pyx_kp_s_Can_only_create_a_buffer_that_is #define __pyx_kp_s_Cannot_assign_to_read_only_memor __pyx_mstate_global->__pyx_kp_s_Cannot_assign_to_read_only_memor #define __pyx_kp_s_Cannot_create_writable_memory_vi __pyx_mstate_global->__pyx_kp_s_Cannot_create_writable_memory_vi #define __pyx_kp_u_Cannot_index_with_type __pyx_mstate_global->__pyx_kp_u_Cannot_index_with_type #define __pyx_kp_s_Cannot_transpose_memoryview_with __pyx_mstate_global->__pyx_kp_s_Cannot_transpose_memoryview_with #define __pyx_kp_s_Dimension_d_is_not_direct __pyx_mstate_global->__pyx_kp_s_Dimension_d_is_not_direct #define __pyx_n_s_Ellipsis __pyx_mstate_global->__pyx_n_s_Ellipsis #define __pyx_kp_s_Empty_shape_tuple_for_cython_arr __pyx_mstate_global->__pyx_kp_s_Empty_shape_tuple_for_cython_arr #define __pyx_n_s_ImportError __pyx_mstate_global->__pyx_n_s_ImportError #define __pyx_kp_s_Incompatible_checksums_0x_x_vs_0 __pyx_mstate_global->__pyx_kp_s_Incompatible_checksums_0x_x_vs_0 #define __pyx_n_s_IndexError __pyx_mstate_global->__pyx_n_s_IndexError #define __pyx_kp_s_Index_out_of_bounds_axis_d __pyx_mstate_global->__pyx_kp_s_Index_out_of_bounds_axis_d #define __pyx_kp_s_Indirect_dimensions_not_supporte __pyx_mstate_global->__pyx_kp_s_Indirect_dimensions_not_supporte #define __pyx_kp_u_Invalid_mode_expected_c_or_fortr __pyx_mstate_global->__pyx_kp_u_Invalid_mode_expected_c_or_fortr #define __pyx_kp_u_Invalid_shape_in_axis __pyx_mstate_global->__pyx_kp_u_Invalid_shape_in_axis #define __pyx_kp_u_Iteration __pyx_mstate_global->__pyx_kp_u_Iteration #define __pyx_n_s_MemoryError __pyx_mstate_global->__pyx_n_s_MemoryError #define __pyx_kp_s_MemoryView_of_r_at_0x_x __pyx_mstate_global->__pyx_kp_s_MemoryView_of_r_at_0x_x #define __pyx_kp_s_MemoryView_of_r_object __pyx_mstate_global->__pyx_kp_s_MemoryView_of_r_object #define __pyx_n_b_O __pyx_mstate_global->__pyx_n_b_O #define __pyx_kp_u_Out_of_bounds_on_buffer_access_a __pyx_mstate_global->__pyx_kp_u_Out_of_bounds_on_buffer_access_a #define __pyx_n_s_PickleError __pyx_mstate_global->__pyx_n_s_PickleError #define __pyx_kp_u_Please_choose_a_supported_PSF_mo __pyx_mstate_global->__pyx_kp_u_Please_choose_a_supported_PSF_mo #define __pyx_kp_u_Please_choose_a_valid_fine_struc __pyx_mstate_global->__pyx_kp_u_Please_choose_a_valid_fine_struc #define __pyx_n_s_Sequence __pyx_mstate_global->__pyx_n_s_Sequence #define __pyx_kp_u_Starting_L_A_Cosmic_iterations __pyx_mstate_global->__pyx_kp_u_Starting_L_A_Cosmic_iterations #define __pyx_kp_s_Step_may_not_be_zero_axis_d __pyx_mstate_global->__pyx_kp_s_Step_may_not_be_zero_axis_d #define __pyx_n_s_TypeError __pyx_mstate_global->__pyx_n_s_TypeError #define __pyx_kp_s_Unable_to_convert_item_to_object __pyx_mstate_global->__pyx_kp_s_Unable_to_convert_item_to_object #define __pyx_n_s_ValueError __pyx_mstate_global->__pyx_n_s_ValueError #define __pyx_n_s_View_MemoryView __pyx_mstate_global->__pyx_n_s_View_MemoryView #define __pyx_kp_u__2 __pyx_mstate_global->__pyx_kp_u__2 #define __pyx_n_s__3 __pyx_mstate_global->__pyx_n_s__3 #define __pyx_n_s__38 __pyx_mstate_global->__pyx_n_s__38 #define __pyx_kp_u__6 __pyx_mstate_global->__pyx_kp_u__6 #define __pyx_kp_u__7 __pyx_mstate_global->__pyx_kp_u__7 #define __pyx_n_s_abc __pyx_mstate_global->__pyx_n_s_abc #define __pyx_n_s_allocate_buffer __pyx_mstate_global->__pyx_n_s_allocate_buffer #define __pyx_kp_u_and __pyx_mstate_global->__pyx_kp_u_and #define __pyx_n_s_arange __pyx_mstate_global->__pyx_n_s_arange #define __pyx_n_s_array __pyx_mstate_global->__pyx_n_s_array #define __pyx_n_s_asarray __pyx_mstate_global->__pyx_n_s_asarray #define __pyx_n_s_astroscrappy_astroscrappy __pyx_mstate_global->__pyx_n_s_astroscrappy_astroscrappy #define __pyx_kp_s_astroscrappy_astroscrappy_pyx __pyx_mstate_global->__pyx_kp_s_astroscrappy_astroscrappy_pyx #define __pyx_n_s_astype __pyx_mstate_global->__pyx_n_s_astype #define __pyx_n_s_asyncio_coroutines __pyx_mstate_global->__pyx_n_s_asyncio_coroutines #define __pyx_n_s_background_level __pyx_mstate_global->__pyx_n_s_background_level #define __pyx_n_s_background_var_level __pyx_mstate_global->__pyx_n_s_background_var_level #define __pyx_n_s_base __pyx_mstate_global->__pyx_n_s_base #define __pyx_n_s_bkg __pyx_mstate_global->__pyx_n_s_bkg #define __pyx_n_s_bool __pyx_mstate_global->__pyx_n_s_bool #define __pyx_n_s_c __pyx_mstate_global->__pyx_n_s_c #define __pyx_n_u_c __pyx_mstate_global->__pyx_n_u_c #define __pyx_n_s_class __pyx_mstate_global->__pyx_n_s_class #define __pyx_n_s_class_getitem __pyx_mstate_global->__pyx_n_s_class_getitem #define __pyx_n_s_clean_var __pyx_mstate_global->__pyx_n_s_clean_var #define __pyx_n_s_cleanarr __pyx_mstate_global->__pyx_n_s_cleanarr #define __pyx_n_s_cleantype __pyx_mstate_global->__pyx_n_s_cleantype #define __pyx_kp_u_cleantype_must_be_one_of_the_fol __pyx_mstate_global->__pyx_kp_u_cleantype_must_be_one_of_the_fol #define __pyx_n_s_cline_in_traceback __pyx_mstate_global->__pyx_n_s_cline_in_traceback #define __pyx_n_s_collections __pyx_mstate_global->__pyx_n_s_collections #define __pyx_kp_s_collections_abc __pyx_mstate_global->__pyx_kp_s_collections_abc #define __pyx_kp_s_contiguous_and_direct __pyx_mstate_global->__pyx_kp_s_contiguous_and_direct #define __pyx_kp_s_contiguous_and_indirect __pyx_mstate_global->__pyx_kp_s_contiguous_and_indirect #define __pyx_n_s_conved __pyx_mstate_global->__pyx_n_s_conved #define __pyx_n_s_convolve __pyx_mstate_global->__pyx_n_s_convolve #define __pyx_n_u_convolve __pyx_mstate_global->__pyx_n_u_convolve #define __pyx_n_s_copy __pyx_mstate_global->__pyx_n_s_copy #define __pyx_kp_u_cosmic_pixels_this_iteration __pyx_mstate_global->__pyx_kp_u_cosmic_pixels_this_iteration #define __pyx_n_s_cosmics __pyx_mstate_global->__pyx_n_s_cosmics #define __pyx_n_s_count __pyx_mstate_global->__pyx_n_s_count #define __pyx_n_s_crmask __pyx_mstate_global->__pyx_n_s_crmask #define __pyx_n_s_data __pyx_mstate_global->__pyx_n_s_data #define __pyx_n_s_detect_cosmics __pyx_mstate_global->__pyx_n_s_detect_cosmics #define __pyx_n_s_dict __pyx_mstate_global->__pyx_n_s_dict #define __pyx_n_s_dilate3 __pyx_mstate_global->__pyx_n_s_dilate3 #define __pyx_n_s_dilate5 __pyx_mstate_global->__pyx_n_s_dilate5 #define __pyx_n_s_dilsatpixels __pyx_mstate_global->__pyx_n_s_dilsatpixels #define __pyx_kp_u_disable __pyx_mstate_global->__pyx_kp_u_disable #define __pyx_n_s_dtype __pyx_mstate_global->__pyx_n_s_dtype #define __pyx_n_s_dtype_is_object __pyx_mstate_global->__pyx_n_s_dtype_is_object #define __pyx_n_s_empty __pyx_mstate_global->__pyx_n_s_empty #define __pyx_n_s_empty_like __pyx_mstate_global->__pyx_n_s_empty_like #define __pyx_kp_u_enable __pyx_mstate_global->__pyx_kp_u_enable #define __pyx_n_s_encode __pyx_mstate_global->__pyx_n_s_encode #define __pyx_n_s_enumerate __pyx_mstate_global->__pyx_n_s_enumerate #define __pyx_n_s_error __pyx_mstate_global->__pyx_n_s_error #define __pyx_n_s_exp __pyx_mstate_global->__pyx_n_s_exp #define __pyx_n_s_f __pyx_mstate_global->__pyx_n_s_f #define __pyx_n_s_flags __pyx_mstate_global->__pyx_n_s_flags #define __pyx_n_s_float32 __pyx_mstate_global->__pyx_n_s_float32 #define __pyx_n_s_format __pyx_mstate_global->__pyx_n_s_format #define __pyx_n_s_fortran __pyx_mstate_global->__pyx_n_s_fortran #define __pyx_n_u_fortran __pyx_mstate_global->__pyx_n_u_fortran #define __pyx_n_s_fsmode __pyx_mstate_global->__pyx_n_s_fsmode #define __pyx_n_s_gain __pyx_mstate_global->__pyx_n_s_gain #define __pyx_n_u_gauss __pyx_mstate_global->__pyx_n_u_gauss #define __pyx_n_s_gausskernel __pyx_mstate_global->__pyx_n_s_gausskernel #define __pyx_n_u_gaussx __pyx_mstate_global->__pyx_n_u_gaussx #define __pyx_n_s_gaussxkernel __pyx_mstate_global->__pyx_n_s_gaussxkernel #define __pyx_n_u_gaussy __pyx_mstate_global->__pyx_n_u_gaussy #define __pyx_n_s_gaussykernel __pyx_mstate_global->__pyx_n_s_gaussykernel #define __pyx_kp_u_gc __pyx_mstate_global->__pyx_kp_u_gc #define __pyx_n_s_getstate __pyx_mstate_global->__pyx_n_s_getstate #define __pyx_n_s_gooddata __pyx_mstate_global->__pyx_n_s_gooddata #define __pyx_n_s_goodpix __pyx_mstate_global->__pyx_n_s_goodpix #define __pyx_n_s_goodvar __pyx_mstate_global->__pyx_n_s_goodvar #define __pyx_kp_u_got __pyx_mstate_global->__pyx_kp_u_got #define __pyx_kp_u_got_differing_extents_in_dimensi __pyx_mstate_global->__pyx_kp_u_got_differing_extents_in_dimensi #define __pyx_n_s_grow_mask __pyx_mstate_global->__pyx_n_s_grow_mask #define __pyx_n_s_i __pyx_mstate_global->__pyx_n_s_i #define __pyx_n_s_id __pyx_mstate_global->__pyx_n_s_id #define __pyx_n_u_idw __pyx_mstate_global->__pyx_n_u_idw #define __pyx_n_s_igoodpix __pyx_mstate_global->__pyx_n_s_igoodpix #define __pyx_n_s_import __pyx_mstate_global->__pyx_n_s_import #define __pyx_n_s_inbkg __pyx_mstate_global->__pyx_n_s_inbkg #define __pyx_n_s_indat __pyx_mstate_global->__pyx_n_s_indat #define __pyx_n_s_index __pyx_mstate_global->__pyx_n_s_index #define __pyx_n_s_initializing __pyx_mstate_global->__pyx_n_s_initializing #define __pyx_n_s_inmask __pyx_mstate_global->__pyx_n_s_inmask #define __pyx_n_s_invar __pyx_mstate_global->__pyx_n_s_invar #define __pyx_n_s_is_coroutine __pyx_mstate_global->__pyx_n_s_is_coroutine #define __pyx_kp_u_isenabled __pyx_mstate_global->__pyx_kp_u_isenabled #define __pyx_n_s_itemsize __pyx_mstate_global->__pyx_n_s_itemsize #define __pyx_kp_s_itemsize_0_for_cython_array __pyx_mstate_global->__pyx_kp_s_itemsize_0_for_cython_array #define __pyx_n_s_j __pyx_mstate_global->__pyx_n_s_j #define __pyx_n_s_kernel __pyx_mstate_global->__pyx_n_s_kernel #define __pyx_n_s_kernsize __pyx_mstate_global->__pyx_n_s_kernsize #define __pyx_n_s_laplaceconvolve __pyx_mstate_global->__pyx_n_s_laplaceconvolve #define __pyx_n_s_logical_and __pyx_mstate_global->__pyx_n_s_logical_and #define __pyx_n_s_logical_not __pyx_mstate_global->__pyx_n_s_logical_not #define __pyx_n_s_logical_or __pyx_mstate_global->__pyx_n_s_logical_or #define __pyx_n_s_m5 __pyx_mstate_global->__pyx_n_s_m5 #define __pyx_n_s_m7 __pyx_mstate_global->__pyx_n_s_m7 #define __pyx_n_s_main __pyx_mstate_global->__pyx_n_s_main #define __pyx_n_s_mask __pyx_mstate_global->__pyx_n_s_mask #define __pyx_n_u_meanmask __pyx_mstate_global->__pyx_n_u_meanmask #define __pyx_n_s_medfilt3 __pyx_mstate_global->__pyx_n_s_medfilt3 #define __pyx_n_s_medfilt5 __pyx_mstate_global->__pyx_n_s_medfilt5 #define __pyx_n_s_medfilt7 __pyx_mstate_global->__pyx_n_s_medfilt7 #define __pyx_n_s_median __pyx_mstate_global->__pyx_n_s_median #define __pyx_n_u_median __pyx_mstate_global->__pyx_n_u_median #define __pyx_n_u_medmask __pyx_mstate_global->__pyx_n_u_medmask #define __pyx_n_s_memview __pyx_mstate_global->__pyx_n_s_memview #define __pyx_n_s_mode __pyx_mstate_global->__pyx_n_s_mode #define __pyx_n_u_moffat __pyx_mstate_global->__pyx_n_u_moffat #define __pyx_n_s_name __pyx_mstate_global->__pyx_n_s_name #define __pyx_n_s_name_2 __pyx_mstate_global->__pyx_n_s_name_2 #define __pyx_n_s_ndim __pyx_mstate_global->__pyx_n_s_ndim #define __pyx_n_s_new __pyx_mstate_global->__pyx_n_s_new #define __pyx_n_s_niter __pyx_mstate_global->__pyx_n_s_niter #define __pyx_kp_s_no_default___reduce___due_to_non __pyx_mstate_global->__pyx_kp_s_no_default___reduce___due_to_non #define __pyx_n_s_noise __pyx_mstate_global->__pyx_n_s_noise #define __pyx_n_s_np __pyx_mstate_global->__pyx_n_s_np #define __pyx_n_s_numcr __pyx_mstate_global->__pyx_n_s_numcr #define __pyx_n_s_numpy __pyx_mstate_global->__pyx_n_s_numpy #define __pyx_kp_u_numpy__core_multiarray_failed_to __pyx_mstate_global->__pyx_kp_u_numpy__core_multiarray_failed_to #define __pyx_kp_u_numpy__core_umath_failed_to_impo __pyx_mstate_global->__pyx_kp_u_numpy__core_umath_failed_to_impo #define __pyx_n_s_nx __pyx_mstate_global->__pyx_n_s_nx #define __pyx_n_s_ny __pyx_mstate_global->__pyx_n_s_ny #define __pyx_n_s_obj __pyx_mstate_global->__pyx_n_s_obj #define __pyx_n_s_objlim __pyx_mstate_global->__pyx_n_s_objlim #define __pyx_n_s_order __pyx_mstate_global->__pyx_n_s_order #define __pyx_n_s_pack __pyx_mstate_global->__pyx_n_s_pack #define __pyx_n_s_pickle __pyx_mstate_global->__pyx_n_s_pickle #define __pyx_n_s_power __pyx_mstate_global->__pyx_n_s_power #define __pyx_n_s_print __pyx_mstate_global->__pyx_n_s_print #define __pyx_n_s_psfbeta __pyx_mstate_global->__pyx_n_s_psfbeta #define __pyx_n_s_psffwhm __pyx_mstate_global->__pyx_n_s_psffwhm #define __pyx_n_s_psfk __pyx_mstate_global->__pyx_n_s_psfk #define __pyx_n_s_psfmodel __pyx_mstate_global->__pyx_n_s_psfmodel #define __pyx_n_s_psfsize __pyx_mstate_global->__pyx_n_s_psfsize #define __pyx_n_s_pyx_PickleError __pyx_mstate_global->__pyx_n_s_pyx_PickleError #define __pyx_n_s_pyx_checksum __pyx_mstate_global->__pyx_n_s_pyx_checksum #define __pyx_n_s_pyx_result __pyx_mstate_global->__pyx_n_s_pyx_result #define __pyx_n_s_pyx_state __pyx_mstate_global->__pyx_n_s_pyx_state #define __pyx_n_s_pyx_type __pyx_mstate_global->__pyx_n_s_pyx_type #define __pyx_n_s_pyx_unpickle_Enum __pyx_mstate_global->__pyx_n_s_pyx_unpickle_Enum #define __pyx_n_s_pyx_vtable __pyx_mstate_global->__pyx_n_s_pyx_vtable #define __pyx_n_s_r2 __pyx_mstate_global->__pyx_n_s_r2 #define __pyx_n_s_range __pyx_mstate_global->__pyx_n_s_range #define __pyx_n_s_readnoise __pyx_mstate_global->__pyx_n_s_readnoise #define __pyx_n_s_rebin __pyx_mstate_global->__pyx_n_s_rebin #define __pyx_n_s_reduce __pyx_mstate_global->__pyx_n_s_reduce #define __pyx_n_s_reduce_cython __pyx_mstate_global->__pyx_n_s_reduce_cython #define __pyx_n_s_reduce_ex __pyx_mstate_global->__pyx_n_s_reduce_ex #define __pyx_n_s_register __pyx_mstate_global->__pyx_n_s_register #define __pyx_n_s_s __pyx_mstate_global->__pyx_n_s_s #define __pyx_n_s_satlevel __pyx_mstate_global->__pyx_n_s_satlevel #define __pyx_n_s_satpixels __pyx_mstate_global->__pyx_n_s_satpixels #define __pyx_n_s_sepmed __pyx_mstate_global->__pyx_n_s_sepmed #define __pyx_n_s_sepmedfilt5 __pyx_mstate_global->__pyx_n_s_sepmedfilt5 #define __pyx_n_s_sepmedfilt7 __pyx_mstate_global->__pyx_n_s_sepmedfilt7 #define __pyx_n_s_sepmedfilt9 __pyx_mstate_global->__pyx_n_s_sepmedfilt9 #define __pyx_n_s_setstate __pyx_mstate_global->__pyx_n_s_setstate #define __pyx_n_s_setstate_cython __pyx_mstate_global->__pyx_n_s_setstate_cython #define __pyx_n_s_shape __pyx_mstate_global->__pyx_n_s_shape #define __pyx_n_s_sigclip __pyx_mstate_global->__pyx_n_s_sigclip #define __pyx_n_s_sigcliplow __pyx_mstate_global->__pyx_n_s_sigcliplow #define __pyx_n_s_sigfrac __pyx_mstate_global->__pyx_n_s_sigfrac #define __pyx_n_s_sigma2 __pyx_mstate_global->__pyx_n_s_sigma2 #define __pyx_n_s_size __pyx_mstate_global->__pyx_n_s_size #define __pyx_n_s_sp __pyx_mstate_global->__pyx_n_s_sp #define __pyx_n_s_spec __pyx_mstate_global->__pyx_n_s_spec #define __pyx_n_s_sqrt __pyx_mstate_global->__pyx_n_s_sqrt #define __pyx_n_s_start __pyx_mstate_global->__pyx_n_s_start #define __pyx_n_s_step __pyx_mstate_global->__pyx_n_s_step #define __pyx_n_s_stop __pyx_mstate_global->__pyx_n_s_stop #define __pyx_kp_s_strided_and_direct __pyx_mstate_global->__pyx_kp_s_strided_and_direct #define __pyx_kp_s_strided_and_direct_or_indirect __pyx_mstate_global->__pyx_kp_s_strided_and_direct_or_indirect #define __pyx_kp_s_strided_and_indirect __pyx_mstate_global->__pyx_kp_s_strided_and_indirect #define __pyx_kp_s_stringsource __pyx_mstate_global->__pyx_kp_s_stringsource #define __pyx_n_s_struct __pyx_mstate_global->__pyx_n_s_struct #define __pyx_n_s_subsam __pyx_mstate_global->__pyx_n_s_subsam #define __pyx_n_s_subsample __pyx_mstate_global->__pyx_n_s_subsample #define __pyx_n_s_sum __pyx_mstate_global->__pyx_n_s_sum #define __pyx_n_s_sys __pyx_mstate_global->__pyx_n_s_sys #define __pyx_n_s_test __pyx_mstate_global->__pyx_n_s_test #define __pyx_n_s_tile __pyx_mstate_global->__pyx_n_s_tile #define __pyx_n_s_transpose __pyx_mstate_global->__pyx_n_s_transpose #define __pyx_n_s_uint8 __pyx_mstate_global->__pyx_n_s_uint8 #define __pyx_kp_s_unable_to_allocate_array_data __pyx_mstate_global->__pyx_kp_s_unable_to_allocate_array_data #define __pyx_kp_s_unable_to_allocate_shape_and_str __pyx_mstate_global->__pyx_kp_s_unable_to_allocate_shape_and_str #define __pyx_n_s_unpack __pyx_mstate_global->__pyx_n_s_unpack #define __pyx_n_s_update __pyx_mstate_global->__pyx_n_s_update #define __pyx_n_s_update_mask __pyx_mstate_global->__pyx_n_s_update_mask #define __pyx_n_s_utils __pyx_mstate_global->__pyx_n_s_utils #define __pyx_n_s_verbose __pyx_mstate_global->__pyx_n_s_verbose #define __pyx_n_s_version_info __pyx_mstate_global->__pyx_n_s_version_info #define __pyx_n_s_x __pyx_mstate_global->__pyx_n_s_x #define __pyx_n_s_y __pyx_mstate_global->__pyx_n_s_y #define __pyx_n_s_zeros __pyx_mstate_global->__pyx_n_s_zeros #define __pyx_float_0_ __pyx_mstate_global->__pyx_float_0_ #define __pyx_float_1_ __pyx_mstate_global->__pyx_float_1_ #define __pyx_float_0_0 __pyx_mstate_global->__pyx_float_0_0 #define __pyx_float_0_5 __pyx_mstate_global->__pyx_float_0_5 #define __pyx_float_1_0 __pyx_mstate_global->__pyx_float_1_0 #define __pyx_float_2_0 __pyx_mstate_global->__pyx_float_2_0 #define __pyx_float_0_01 __pyx_mstate_global->__pyx_float_0_01 #define __pyx_float_0_00001 __pyx_mstate_global->__pyx_float_0_00001 #define __pyx_float_0_4472136 __pyx_mstate_global->__pyx_float_0_4472136 #define __pyx_float_0_35355339 __pyx_mstate_global->__pyx_float_0_35355339 #define __pyx_float_0_70710678 __pyx_mstate_global->__pyx_float_0_70710678 #define __pyx_float_neg_0_5 __pyx_mstate_global->__pyx_float_neg_0_5 #define __pyx_int_0 __pyx_mstate_global->__pyx_int_0 #define __pyx_int_1 __pyx_mstate_global->__pyx_int_1 #define __pyx_int_2 __pyx_mstate_global->__pyx_int_2 #define __pyx_int_3 __pyx_mstate_global->__pyx_int_3 #define __pyx_int_112105877 __pyx_mstate_global->__pyx_int_112105877 #define __pyx_int_136983863 __pyx_mstate_global->__pyx_int_136983863 #define __pyx_int_184977713 __pyx_mstate_global->__pyx_int_184977713 #define __pyx_int_neg_1 __pyx_mstate_global->__pyx_int_neg_1 #define __pyx_slice__5 __pyx_mstate_global->__pyx_slice__5 #define __pyx_tuple__4 __pyx_mstate_global->__pyx_tuple__4 #define __pyx_tuple__8 __pyx_mstate_global->__pyx_tuple__8 #define __pyx_tuple__9 __pyx_mstate_global->__pyx_tuple__9 #define __pyx_slice__13 __pyx_mstate_global->__pyx_slice__13 #define __pyx_tuple__10 __pyx_mstate_global->__pyx_tuple__10 #define __pyx_tuple__11 __pyx_mstate_global->__pyx_tuple__11 #define __pyx_tuple__12 __pyx_mstate_global->__pyx_tuple__12 #define __pyx_tuple__14 __pyx_mstate_global->__pyx_tuple__14 #define __pyx_tuple__15 __pyx_mstate_global->__pyx_tuple__15 #define __pyx_tuple__16 __pyx_mstate_global->__pyx_tuple__16 #define __pyx_tuple__17 __pyx_mstate_global->__pyx_tuple__17 #define __pyx_tuple__18 __pyx_mstate_global->__pyx_tuple__18 #define __pyx_tuple__19 __pyx_mstate_global->__pyx_tuple__19 #define __pyx_tuple__20 __pyx_mstate_global->__pyx_tuple__20 #define __pyx_tuple__21 __pyx_mstate_global->__pyx_tuple__21 #define __pyx_tuple__22 __pyx_mstate_global->__pyx_tuple__22 #define __pyx_tuple__23 __pyx_mstate_global->__pyx_tuple__23 #define __pyx_tuple__24 __pyx_mstate_global->__pyx_tuple__24 #define __pyx_tuple__25 __pyx_mstate_global->__pyx_tuple__25 #define __pyx_tuple__26 __pyx_mstate_global->__pyx_tuple__26 #define __pyx_tuple__28 __pyx_mstate_global->__pyx_tuple__28 #define __pyx_tuple__30 __pyx_mstate_global->__pyx_tuple__30 #define __pyx_tuple__32 __pyx_mstate_global->__pyx_tuple__32 #define __pyx_tuple__34 __pyx_mstate_global->__pyx_tuple__34 #define __pyx_tuple__36 __pyx_mstate_global->__pyx_tuple__36 #define __pyx_codeobj__27 __pyx_mstate_global->__pyx_codeobj__27 #define __pyx_codeobj__29 __pyx_mstate_global->__pyx_codeobj__29 #define __pyx_codeobj__31 __pyx_mstate_global->__pyx_codeobj__31 #define __pyx_codeobj__33 __pyx_mstate_global->__pyx_codeobj__33 #define __pyx_codeobj__35 __pyx_mstate_global->__pyx_codeobj__35 #define __pyx_codeobj__37 __pyx_mstate_global->__pyx_codeobj__37 /* #### Code section: module_code ### */ /* "View.MemoryView":131 * 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; CYTHON_UNUSED Py_ssize_t __pyx_nargs; CYTHON_UNUSED PyObject *const *__pyx_kwvalues; PyObject* values[5] = {0,0,0,0,0}; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; int __pyx_r; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__cinit__ (wrapper)", 0); #if CYTHON_ASSUME_SAFE_MACROS __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); #else __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return -1; #endif __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs); { 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}; values[3] = __Pyx_Arg_NewRef_VARARGS(((PyObject *)__pyx_n_s_c)); if (__pyx_kwds) { Py_ssize_t kw_args; switch (__pyx_nargs) { case 5: values[4] = __Pyx_Arg_VARARGS(__pyx_args, 4); CYTHON_FALLTHROUGH; case 4: values[3] = __Pyx_Arg_VARARGS(__pyx_args, 3); CYTHON_FALLTHROUGH; case 3: values[2] = __Pyx_Arg_VARARGS(__pyx_args, 2); CYTHON_FALLTHROUGH; case 2: values[1] = __Pyx_Arg_VARARGS(__pyx_args, 1); CYTHON_FALLTHROUGH; case 1: values[0] = __Pyx_Arg_VARARGS(__pyx_args, 0); CYTHON_FALLTHROUGH; case 0: break; default: goto __pyx_L5_argtuple_error; } kw_args = __Pyx_NumKwargs_VARARGS(__pyx_kwds); switch (__pyx_nargs) { case 0: if (likely((values[0] = __Pyx_GetKwValue_VARARGS(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_shape)) != 0)) { (void)__Pyx_Arg_NewRef_VARARGS(values[0]); kw_args--; } else if (unlikely(PyErr_Occurred())) __PYX_ERR(1, 131, __pyx_L3_error) else goto __pyx_L5_argtuple_error; CYTHON_FALLTHROUGH; case 1: if (likely((values[1] = __Pyx_GetKwValue_VARARGS(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_itemsize)) != 0)) { (void)__Pyx_Arg_NewRef_VARARGS(values[1]); kw_args--; } else if (unlikely(PyErr_Occurred())) __PYX_ERR(1, 131, __pyx_L3_error) else { __Pyx_RaiseArgtupleInvalid("__cinit__", 0, 3, 5, 1); __PYX_ERR(1, 131, __pyx_L3_error) } CYTHON_FALLTHROUGH; case 2: if (likely((values[2] = __Pyx_GetKwValue_VARARGS(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_format)) != 0)) { (void)__Pyx_Arg_NewRef_VARARGS(values[2]); kw_args--; } else if (unlikely(PyErr_Occurred())) __PYX_ERR(1, 131, __pyx_L3_error) else { __Pyx_RaiseArgtupleInvalid("__cinit__", 0, 3, 5, 2); __PYX_ERR(1, 131, __pyx_L3_error) } CYTHON_FALLTHROUGH; case 3: if (kw_args > 0) { PyObject* value = __Pyx_GetKwValue_VARARGS(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_mode); if (value) { values[3] = __Pyx_Arg_NewRef_VARARGS(value); kw_args--; } else if (unlikely(PyErr_Occurred())) __PYX_ERR(1, 131, __pyx_L3_error) } CYTHON_FALLTHROUGH; case 4: if (kw_args > 0) { PyObject* value = __Pyx_GetKwValue_VARARGS(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_allocate_buffer); if (value) { values[4] = __Pyx_Arg_NewRef_VARARGS(value); kw_args--; } else if (unlikely(PyErr_Occurred())) __PYX_ERR(1, 131, __pyx_L3_error) } } if (unlikely(kw_args > 0)) { const Py_ssize_t kwd_pos_args = __pyx_nargs; if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "__cinit__") < 0)) __PYX_ERR(1, 131, __pyx_L3_error) } } else { switch (__pyx_nargs) { case 5: values[4] = __Pyx_Arg_VARARGS(__pyx_args, 4); CYTHON_FALLTHROUGH; case 4: values[3] = __Pyx_Arg_VARARGS(__pyx_args, 3); CYTHON_FALLTHROUGH; case 3: values[2] = __Pyx_Arg_VARARGS(__pyx_args, 2); values[1] = __Pyx_Arg_VARARGS(__pyx_args, 1); values[0] = __Pyx_Arg_VARARGS(__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, 131, __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, 132, __pyx_L3_error) } else { /* "View.MemoryView":132 * * 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_L6_skip; __pyx_L5_argtuple_error:; __Pyx_RaiseArgtupleInvalid("__cinit__", 0, 3, 5, __pyx_nargs); __PYX_ERR(1, 131, __pyx_L3_error) __pyx_L6_skip:; goto __pyx_L4_argument_unpacking_done; __pyx_L3_error:; { Py_ssize_t __pyx_temp; for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { __Pyx_Arg_XDECREF_VARARGS(values[__pyx_temp]); } } __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, 131, __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, 131, __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":131 * 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:; { Py_ssize_t __pyx_temp; for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { __Pyx_Arg_XDECREF_VARARGS(values[__pyx_temp]); } } __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_dim; char __pyx_v_order; int __pyx_r; __Pyx_RefNannyDeclarations Py_ssize_t __pyx_t_1; 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; char *__pyx_t_8; Py_ssize_t __pyx_t_9; Py_UCS4 __pyx_t_10; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("__cinit__", 0); __Pyx_INCREF(__pyx_v_format); /* "View.MemoryView":137 * cdef Py_ssize_t dim * * 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, 137, __pyx_L1_error) } __pyx_t_1 = __Pyx_PyTuple_GET_SIZE(__pyx_v_shape); if (unlikely(__pyx_t_1 == ((Py_ssize_t)-1))) __PYX_ERR(1, 137, __pyx_L1_error) __pyx_v_self->ndim = ((int)__pyx_t_1); /* "View.MemoryView":138 * * self.ndim = len(shape) * self.itemsize = itemsize # <<<<<<<<<<<<<< * * if not self.ndim: */ __pyx_v_self->itemsize = __pyx_v_itemsize; /* "View.MemoryView":140 * self.itemsize = itemsize * * if not self.ndim: # <<<<<<<<<<<<<< * raise ValueError, "Empty shape tuple for cython.array" * */ __pyx_t_2 = (!(__pyx_v_self->ndim != 0)); if (unlikely(__pyx_t_2)) { /* "View.MemoryView":141 * * if not self.ndim: * raise ValueError, "Empty shape tuple for cython.array" # <<<<<<<<<<<<<< * * if itemsize <= 0: */ __Pyx_Raise(__pyx_builtin_ValueError, __pyx_kp_s_Empty_shape_tuple_for_cython_arr, 0, 0); __PYX_ERR(1, 141, __pyx_L1_error) /* "View.MemoryView":140 * self.itemsize = itemsize * * if not self.ndim: # <<<<<<<<<<<<<< * raise ValueError, "Empty shape tuple for cython.array" * */ } /* "View.MemoryView":143 * 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); if (unlikely(__pyx_t_2)) { /* "View.MemoryView":144 * * if itemsize <= 0: * raise ValueError, "itemsize <= 0 for cython.array" # <<<<<<<<<<<<<< * * if not isinstance(format, bytes): */ __Pyx_Raise(__pyx_builtin_ValueError, __pyx_kp_s_itemsize_0_for_cython_array, 0, 0); __PYX_ERR(1, 144, __pyx_L1_error) /* "View.MemoryView":143 * raise ValueError, "Empty shape tuple for cython.array" * * if itemsize <= 0: # <<<<<<<<<<<<<< * raise ValueError, "itemsize <= 0 for cython.array" * */ } /* "View.MemoryView":146 * 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_3 = (!__pyx_t_2); if (__pyx_t_3) { /* "View.MemoryView":147 * * 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, 147, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_5); __pyx_t_6 = NULL; __pyx_t_7 = 0; #if CYTHON_UNPACK_METHODS if (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_7 = 1; } } #endif { PyObject *__pyx_callargs[2] = {__pyx_t_6, __pyx_n_s_ASCII}; __pyx_t_4 = __Pyx_PyObject_FastCall(__pyx_t_5, __pyx_callargs+1-__pyx_t_7, 1+__pyx_t_7); __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0; if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 147, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; } __Pyx_DECREF_SET(__pyx_v_format, __pyx_t_4); __pyx_t_4 = 0; /* "View.MemoryView":146 * 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":148 * 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) || __Pyx_RaiseUnexpectedTypeError("bytes", __pyx_v_format))) __PYX_ERR(1, 148, __pyx_L1_error) __pyx_t_4 = __pyx_v_format; __Pyx_INCREF(__pyx_t_4); __Pyx_GIVEREF(__pyx_t_4); __Pyx_GOTREF(__pyx_v_self->_format); __Pyx_DECREF(__pyx_v_self->_format); __pyx_v_self->_format = ((PyObject*)__pyx_t_4); __pyx_t_4 = 0; /* "View.MemoryView":149 * 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, 149, __pyx_L1_error) } __pyx_t_8 = __Pyx_PyBytes_AsWritableString(__pyx_v_self->_format); if (unlikely((!__pyx_t_8) && PyErr_Occurred())) __PYX_ERR(1, 149, __pyx_L1_error) __pyx_v_self->format = __pyx_t_8; /* "View.MemoryView":152 * * * 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":153 * * 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":155 * self._strides = self._shape + self.ndim * * if not self._shape: # <<<<<<<<<<<<<< * raise MemoryError, "unable to allocate shape and strides." * */ __pyx_t_3 = (!(__pyx_v_self->_shape != 0)); if (unlikely(__pyx_t_3)) { /* "View.MemoryView":156 * * if not self._shape: * raise MemoryError, "unable to allocate shape and strides." # <<<<<<<<<<<<<< * * */ __Pyx_Raise(__pyx_builtin_MemoryError, __pyx_kp_s_unable_to_allocate_shape_and_str, 0, 0); __PYX_ERR(1, 156, __pyx_L1_error) /* "View.MemoryView":155 * self._strides = self._shape + self.ndim * * if not self._shape: # <<<<<<<<<<<<<< * raise MemoryError, "unable to allocate shape and strides." * */ } /* "View.MemoryView":159 * * * for idx, dim in enumerate(shape): # <<<<<<<<<<<<<< * if dim <= 0: * raise ValueError, f"Invalid shape in axis {idx}: {dim}." */ __pyx_t_7 = 0; __pyx_t_4 = __pyx_v_shape; __Pyx_INCREF(__pyx_t_4); __pyx_t_1 = 0; for (;;) { { Py_ssize_t __pyx_temp = __Pyx_PyTuple_GET_SIZE(__pyx_t_4); #if !CYTHON_ASSUME_SAFE_MACROS if (unlikely((__pyx_temp < 0))) __PYX_ERR(1, 159, __pyx_L1_error) #endif if (__pyx_t_1 >= __pyx_temp) break; } #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS __pyx_t_5 = PyTuple_GET_ITEM(__pyx_t_4, __pyx_t_1); __Pyx_INCREF(__pyx_t_5); __pyx_t_1++; if (unlikely((0 < 0))) __PYX_ERR(1, 159, __pyx_L1_error) #else __pyx_t_5 = __Pyx_PySequence_ITEM(__pyx_t_4, __pyx_t_1); __pyx_t_1++; if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 159, __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, 159, __pyx_L1_error) __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; __pyx_v_dim = __pyx_t_9; __pyx_v_idx = __pyx_t_7; __pyx_t_7 = (__pyx_t_7 + 1); /* "View.MemoryView":160 * * for idx, dim in enumerate(shape): * if dim <= 0: # <<<<<<<<<<<<<< * raise ValueError, f"Invalid shape in axis {idx}: {dim}." * self._shape[idx] = dim */ __pyx_t_3 = (__pyx_v_dim <= 0); if (unlikely(__pyx_t_3)) { /* "View.MemoryView":161 * for idx, dim in enumerate(shape): * if dim <= 0: * raise ValueError, f"Invalid shape in axis {idx}: {dim}." # <<<<<<<<<<<<<< * self._shape[idx] = dim * */ __pyx_t_5 = PyTuple_New(5); if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 161, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_5); __pyx_t_9 = 0; __pyx_t_10 = 127; __Pyx_INCREF(__pyx_kp_u_Invalid_shape_in_axis); __pyx_t_9 += 22; __Pyx_GIVEREF(__pyx_kp_u_Invalid_shape_in_axis); PyTuple_SET_ITEM(__pyx_t_5, 0, __pyx_kp_u_Invalid_shape_in_axis); __pyx_t_6 = __Pyx_PyUnicode_From_int(__pyx_v_idx, 0, ' ', 'd'); if (unlikely(!__pyx_t_6)) __PYX_ERR(1, 161, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); __pyx_t_9 += __Pyx_PyUnicode_GET_LENGTH(__pyx_t_6); __Pyx_GIVEREF(__pyx_t_6); PyTuple_SET_ITEM(__pyx_t_5, 1, __pyx_t_6); __pyx_t_6 = 0; __Pyx_INCREF(__pyx_kp_u_); __pyx_t_9 += 2; __Pyx_GIVEREF(__pyx_kp_u_); PyTuple_SET_ITEM(__pyx_t_5, 2, __pyx_kp_u_); __pyx_t_6 = __Pyx_PyUnicode_From_Py_ssize_t(__pyx_v_dim, 0, ' ', 'd'); if (unlikely(!__pyx_t_6)) __PYX_ERR(1, 161, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); __pyx_t_9 += __Pyx_PyUnicode_GET_LENGTH(__pyx_t_6); __Pyx_GIVEREF(__pyx_t_6); PyTuple_SET_ITEM(__pyx_t_5, 3, __pyx_t_6); __pyx_t_6 = 0; __Pyx_INCREF(__pyx_kp_u__2); __pyx_t_9 += 1; __Pyx_GIVEREF(__pyx_kp_u__2); PyTuple_SET_ITEM(__pyx_t_5, 4, __pyx_kp_u__2); __pyx_t_6 = __Pyx_PyUnicode_Join(__pyx_t_5, 5, __pyx_t_9, __pyx_t_10); if (unlikely(!__pyx_t_6)) __PYX_ERR(1, 161, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; __Pyx_Raise(__pyx_builtin_ValueError, __pyx_t_6, 0, 0); __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; __PYX_ERR(1, 161, __pyx_L1_error) /* "View.MemoryView":160 * * for idx, dim in enumerate(shape): * if dim <= 0: # <<<<<<<<<<<<<< * raise ValueError, f"Invalid shape in axis {idx}: {dim}." * self._shape[idx] = dim */ } /* "View.MemoryView":162 * if dim <= 0: * raise ValueError, f"Invalid shape in axis {idx}: {dim}." * self._shape[idx] = dim # <<<<<<<<<<<<<< * * cdef char order */ (__pyx_v_self->_shape[__pyx_v_idx]) = __pyx_v_dim; /* "View.MemoryView":159 * * * for idx, dim in enumerate(shape): # <<<<<<<<<<<<<< * if dim <= 0: * raise ValueError, f"Invalid shape in axis {idx}: {dim}." */ } __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; /* "View.MemoryView":165 * * cdef char order * if mode == 'c': # <<<<<<<<<<<<<< * order = b'C' * self.mode = u'c' */ __pyx_t_3 = (__Pyx_PyString_Equals(__pyx_v_mode, __pyx_n_s_c, Py_EQ)); if (unlikely((__pyx_t_3 < 0))) __PYX_ERR(1, 165, __pyx_L1_error) if (__pyx_t_3) { /* "View.MemoryView":166 * cdef char order * if mode == 'c': * order = b'C' # <<<<<<<<<<<<<< * self.mode = u'c' * elif mode == 'fortran': */ __pyx_v_order = 'C'; /* "View.MemoryView":167 * if mode == 'c': * order = b'C' * self.mode = u'c' # <<<<<<<<<<<<<< * elif mode == 'fortran': * order = b'F' */ __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":165 * * cdef char order * if mode == 'c': # <<<<<<<<<<<<<< * order = b'C' * self.mode = u'c' */ goto __pyx_L11; } /* "View.MemoryView":168 * order = b'C' * self.mode = u'c' * elif mode == 'fortran': # <<<<<<<<<<<<<< * order = b'F' * self.mode = u'fortran' */ __pyx_t_3 = (__Pyx_PyString_Equals(__pyx_v_mode, __pyx_n_s_fortran, Py_EQ)); if (unlikely((__pyx_t_3 < 0))) __PYX_ERR(1, 168, __pyx_L1_error) if (likely(__pyx_t_3)) { /* "View.MemoryView":169 * self.mode = u'c' * elif mode == 'fortran': * order = b'F' # <<<<<<<<<<<<<< * self.mode = u'fortran' * else: */ __pyx_v_order = 'F'; /* "View.MemoryView":170 * elif mode == 'fortran': * order = b'F' * self.mode = u'fortran' # <<<<<<<<<<<<<< * else: * raise ValueError, f"Invalid mode, expected 'c' or 'fortran', got {mode}" */ __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":168 * order = b'C' * self.mode = u'c' * elif mode == 'fortran': # <<<<<<<<<<<<<< * order = b'F' * self.mode = u'fortran' */ goto __pyx_L11; } /* "View.MemoryView":172 * self.mode = u'fortran' * else: * raise ValueError, f"Invalid mode, expected 'c' or 'fortran', got {mode}" # <<<<<<<<<<<<<< * * self.len = fill_contig_strides_array(self._shape, self._strides, itemsize, self.ndim, order) */ /*else*/ { __pyx_t_4 = __Pyx_PyObject_FormatSimple(__pyx_v_mode, __pyx_empty_unicode); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 172, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __pyx_t_6 = __Pyx_PyUnicode_Concat(__pyx_kp_u_Invalid_mode_expected_c_or_fortr, __pyx_t_4); if (unlikely(!__pyx_t_6)) __PYX_ERR(1, 172, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __Pyx_Raise(__pyx_builtin_ValueError, __pyx_t_6, 0, 0); __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; __PYX_ERR(1, 172, __pyx_L1_error) } __pyx_L11:; /* "View.MemoryView":174 * raise ValueError, f"Invalid mode, expected 'c' or 'fortran', got {mode}" * * self.len = fill_contig_strides_array(self._shape, self._strides, itemsize, self.ndim, order) # <<<<<<<<<<<<<< * * self.free_data = allocate_buffer */ __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":176 * self.len = fill_contig_strides_array(self._shape, self._strides, itemsize, self.ndim, order) * * self.free_data = allocate_buffer # <<<<<<<<<<<<<< * self.dtype_is_object = format == b'O' * */ __pyx_v_self->free_data = __pyx_v_allocate_buffer; /* "View.MemoryView":177 * * self.free_data = allocate_buffer * self.dtype_is_object = format == b'O' # <<<<<<<<<<<<<< * * if allocate_buffer: */ __pyx_t_6 = PyObject_RichCompare(__pyx_v_format, __pyx_n_b_O, Py_EQ); __Pyx_XGOTREF(__pyx_t_6); if (unlikely(!__pyx_t_6)) __PYX_ERR(1, 177, __pyx_L1_error) __pyx_t_3 = __Pyx_PyObject_IsTrue(__pyx_t_6); if (unlikely((__pyx_t_3 == (int)-1) && PyErr_Occurred())) __PYX_ERR(1, 177, __pyx_L1_error) __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; __pyx_v_self->dtype_is_object = __pyx_t_3; /* "View.MemoryView":179 * self.dtype_is_object = format == b'O' * * if allocate_buffer: # <<<<<<<<<<<<<< * _allocate_buffer(self) * */ if (__pyx_v_allocate_buffer) { /* "View.MemoryView":180 * * if allocate_buffer: * _allocate_buffer(self) # <<<<<<<<<<<<<< * * @cname('getbuffer') */ __pyx_t_7 = __pyx_array_allocate_buffer(__pyx_v_self); if (unlikely(__pyx_t_7 == ((int)-1))) __PYX_ERR(1, 180, __pyx_L1_error) /* "View.MemoryView":179 * self.dtype_is_object = format == b'O' * * if allocate_buffer: # <<<<<<<<<<<<<< * _allocate_buffer(self) * */ } /* "View.MemoryView":131 * 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_4); __Pyx_XDECREF(__pyx_t_5); __Pyx_XDECREF(__pyx_t_6); __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":182 * _allocate_buffer(self) * * @cname('getbuffer') # <<<<<<<<<<<<<< * def __getbuffer__(self, Py_buffer *info, int flags): * cdef int bufmode = -1 */ /* Python wrapper */ CYTHON_UNUSED static int __pyx_array_getbuffer(PyObject *__pyx_v_self, Py_buffer *__pyx_v_info, int __pyx_v_flags); /*proto*/ CYTHON_UNUSED static int __pyx_array_getbuffer(PyObject *__pyx_v_self, Py_buffer *__pyx_v_info, int __pyx_v_flags) { CYTHON_UNUSED PyObject *const *__pyx_kwvalues; int __pyx_r; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__getbuffer__ (wrapper)", 0); __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs); __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; char *__pyx_t_2; Py_ssize_t __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; if (unlikely(__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":184 * @cname('getbuffer') * def __getbuffer__(self, Py_buffer *info, int flags): * cdef int bufmode = -1 # <<<<<<<<<<<<<< * if flags & (PyBUF_C_CONTIGUOUS | PyBUF_F_CONTIGUOUS | PyBUF_ANY_CONTIGUOUS): * if self.mode == u"c": */ __pyx_v_bufmode = -1; /* "View.MemoryView":185 * def __getbuffer__(self, Py_buffer *info, int flags): * cdef int bufmode = -1 * if flags & (PyBUF_C_CONTIGUOUS | PyBUF_F_CONTIGUOUS | PyBUF_ANY_CONTIGUOUS): # <<<<<<<<<<<<<< * if self.mode == u"c": * bufmode = PyBUF_C_CONTIGUOUS | PyBUF_ANY_CONTIGUOUS */ __pyx_t_1 = ((__pyx_v_flags & ((PyBUF_C_CONTIGUOUS | PyBUF_F_CONTIGUOUS) | PyBUF_ANY_CONTIGUOUS)) != 0); if (__pyx_t_1) { /* "View.MemoryView":186 * cdef int bufmode = -1 * if flags & (PyBUF_C_CONTIGUOUS | PyBUF_F_CONTIGUOUS | PyBUF_ANY_CONTIGUOUS): * 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, 186, __pyx_L1_error) if (__pyx_t_1) { /* "View.MemoryView":187 * if flags & (PyBUF_C_CONTIGUOUS | PyBUF_F_CONTIGUOUS | PyBUF_ANY_CONTIGUOUS): * 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":186 * cdef int bufmode = -1 * if flags & (PyBUF_C_CONTIGUOUS | PyBUF_F_CONTIGUOUS | PyBUF_ANY_CONTIGUOUS): * if self.mode == u"c": # <<<<<<<<<<<<<< * bufmode = PyBUF_C_CONTIGUOUS | PyBUF_ANY_CONTIGUOUS * elif self.mode == u"fortran": */ goto __pyx_L4; } /* "View.MemoryView":188 * 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_1 = (__Pyx_PyUnicode_Equals(__pyx_v_self->mode, __pyx_n_u_fortran, Py_EQ)); if (unlikely((__pyx_t_1 < 0))) __PYX_ERR(1, 188, __pyx_L1_error) if (__pyx_t_1) { /* "View.MemoryView":189 * 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":188 * 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_L4:; /* "View.MemoryView":190 * 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)); if (unlikely(__pyx_t_1)) { /* "View.MemoryView":191 * 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_Raise(__pyx_builtin_ValueError, __pyx_kp_s_Can_only_create_a_buffer_that_is, 0, 0); __PYX_ERR(1, 191, __pyx_L1_error) /* "View.MemoryView":190 * 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":185 * def __getbuffer__(self, Py_buffer *info, int flags): * cdef int bufmode = -1 * if flags & (PyBUF_C_CONTIGUOUS | PyBUF_F_CONTIGUOUS | PyBUF_ANY_CONTIGUOUS): # <<<<<<<<<<<<<< * if self.mode == u"c": * bufmode = PyBUF_C_CONTIGUOUS | PyBUF_ANY_CONTIGUOUS */ } /* "View.MemoryView":192 * 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_2 = __pyx_v_self->data; __pyx_v_info->buf = __pyx_t_2; /* "View.MemoryView":193 * raise ValueError, "Can only create a buffer that is contiguous in memory." * info.buf = self.data * info.len = self.len # <<<<<<<<<<<<<< * * if flags & PyBUF_STRIDES: */ __pyx_t_3 = __pyx_v_self->len; __pyx_v_info->len = __pyx_t_3; /* "View.MemoryView":195 * info.len = self.len * * if flags & PyBUF_STRIDES: # <<<<<<<<<<<<<< * info.ndim = self.ndim * info.shape = self._shape */ __pyx_t_1 = ((__pyx_v_flags & PyBUF_STRIDES) != 0); if (__pyx_t_1) { /* "View.MemoryView":196 * * if flags & PyBUF_STRIDES: * info.ndim = self.ndim # <<<<<<<<<<<<<< * info.shape = self._shape * info.strides = self._strides */ __pyx_t_4 = __pyx_v_self->ndim; __pyx_v_info->ndim = __pyx_t_4; /* "View.MemoryView":197 * if flags & PyBUF_STRIDES: * info.ndim = self.ndim * info.shape = self._shape # <<<<<<<<<<<<<< * info.strides = self._strides * else: */ __pyx_t_5 = __pyx_v_self->_shape; __pyx_v_info->shape = __pyx_t_5; /* "View.MemoryView":198 * info.ndim = self.ndim * info.shape = self._shape * info.strides = self._strides # <<<<<<<<<<<<<< * else: * info.ndim = 1 */ __pyx_t_5 = __pyx_v_self->_strides; __pyx_v_info->strides = __pyx_t_5; /* "View.MemoryView":195 * info.len = self.len * * if flags & PyBUF_STRIDES: # <<<<<<<<<<<<<< * info.ndim = self.ndim * info.shape = self._shape */ goto __pyx_L6; } /* "View.MemoryView":200 * info.strides = self._strides * else: * info.ndim = 1 # <<<<<<<<<<<<<< * info.shape = &self.len if flags & PyBUF_ND else NULL * info.strides = NULL */ /*else*/ { __pyx_v_info->ndim = 1; /* "View.MemoryView":201 * else: * info.ndim = 1 * info.shape = &self.len if flags & PyBUF_ND else NULL # <<<<<<<<<<<<<< * info.strides = NULL * */ __pyx_t_1 = ((__pyx_v_flags & PyBUF_ND) != 0); if (__pyx_t_1) { __pyx_t_5 = (&__pyx_v_self->len); } else { __pyx_t_5 = NULL; } __pyx_v_info->shape = __pyx_t_5; /* "View.MemoryView":202 * info.ndim = 1 * info.shape = &self.len if flags & PyBUF_ND else NULL * info.strides = NULL # <<<<<<<<<<<<<< * * info.suboffsets = NULL */ __pyx_v_info->strides = NULL; } __pyx_L6:; /* "View.MemoryView":204 * info.strides = NULL * * info.suboffsets = NULL # <<<<<<<<<<<<<< * info.itemsize = self.itemsize * info.readonly = 0 */ __pyx_v_info->suboffsets = NULL; /* "View.MemoryView":205 * * info.suboffsets = NULL * info.itemsize = self.itemsize # <<<<<<<<<<<<<< * info.readonly = 0 * info.format = self.format if flags & PyBUF_FORMAT else NULL */ __pyx_t_3 = __pyx_v_self->itemsize; __pyx_v_info->itemsize = __pyx_t_3; /* "View.MemoryView":206 * info.suboffsets = NULL * info.itemsize = self.itemsize * info.readonly = 0 # <<<<<<<<<<<<<< * info.format = self.format if flags & PyBUF_FORMAT else NULL * info.obj = self */ __pyx_v_info->readonly = 0; /* "View.MemoryView":207 * info.itemsize = self.itemsize * info.readonly = 0 * info.format = self.format if flags & PyBUF_FORMAT else NULL # <<<<<<<<<<<<<< * info.obj = self * */ __pyx_t_1 = ((__pyx_v_flags & PyBUF_FORMAT) != 0); if (__pyx_t_1) { __pyx_t_2 = __pyx_v_self->format; } else { __pyx_t_2 = NULL; } __pyx_v_info->format = __pyx_t_2; /* "View.MemoryView":208 * info.readonly = 0 * info.format = self.format if flags & PyBUF_FORMAT else NULL * info.obj = self # <<<<<<<<<<<<<< * * def __dealloc__(array self): */ __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":182 * _allocate_buffer(self) * * @cname('getbuffer') # <<<<<<<<<<<<<< * def __getbuffer__(self, Py_buffer *info, int flags): * cdef int bufmode = -1 */ /* function exit code */ __pyx_r = 0; goto __pyx_L0; __pyx_L1_error:; __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":210 * info.obj = self * * 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) { CYTHON_UNUSED PyObject *const *__pyx_kwvalues; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__dealloc__ (wrapper)", 0); __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs); __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) { int __pyx_t_1; int __pyx_t_2; /* "View.MemoryView":211 * * def __dealloc__(array self): * if self.callback_free_data != NULL: # <<<<<<<<<<<<<< * self.callback_free_data(self.data) * elif self.free_data and self.data is not NULL: */ __pyx_t_1 = (__pyx_v_self->callback_free_data != NULL); if (__pyx_t_1) { /* "View.MemoryView":212 * def __dealloc__(array self): * if self.callback_free_data != NULL: * self.callback_free_data(self.data) # <<<<<<<<<<<<<< * elif self.free_data and self.data is not NULL: * if self.dtype_is_object: */ __pyx_v_self->callback_free_data(__pyx_v_self->data); /* "View.MemoryView":211 * * def __dealloc__(array self): * if self.callback_free_data != NULL: # <<<<<<<<<<<<<< * self.callback_free_data(self.data) * elif self.free_data and self.data is not NULL: */ goto __pyx_L3; } /* "View.MemoryView":213 * if self.callback_free_data != NULL: * self.callback_free_data(self.data) * elif self.free_data and self.data is not NULL: # <<<<<<<<<<<<<< * if self.dtype_is_object: * refcount_objects_in_slice(self.data, self._shape, self._strides, self.ndim, inc=False) */ if (__pyx_v_self->free_data) { } else { __pyx_t_1 = __pyx_v_self->free_data; goto __pyx_L4_bool_binop_done; } __pyx_t_2 = (__pyx_v_self->data != NULL); __pyx_t_1 = __pyx_t_2; __pyx_L4_bool_binop_done:; if (__pyx_t_1) { /* "View.MemoryView":214 * self.callback_free_data(self.data) * elif self.free_data and self.data is not NULL: * if self.dtype_is_object: # <<<<<<<<<<<<<< * refcount_objects_in_slice(self.data, self._shape, self._strides, self.ndim, inc=False) * free(self.data) */ if (__pyx_v_self->dtype_is_object) { /* "View.MemoryView":215 * elif self.free_data and self.data is not NULL: * if self.dtype_is_object: * refcount_objects_in_slice(self.data, self._shape, self._strides, self.ndim, inc=False) # <<<<<<<<<<<<<< * free(self.data) * PyObject_Free(self._shape) */ __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":214 * self.callback_free_data(self.data) * elif self.free_data and self.data is not NULL: * if self.dtype_is_object: # <<<<<<<<<<<<<< * refcount_objects_in_slice(self.data, self._shape, self._strides, self.ndim, inc=False) * free(self.data) */ } /* "View.MemoryView":216 * if self.dtype_is_object: * refcount_objects_in_slice(self.data, self._shape, self._strides, self.ndim, inc=False) * free(self.data) # <<<<<<<<<<<<<< * PyObject_Free(self._shape) * */ free(__pyx_v_self->data); /* "View.MemoryView":213 * if self.callback_free_data != NULL: * self.callback_free_data(self.data) * elif self.free_data and self.data is not NULL: # <<<<<<<<<<<<<< * if self.dtype_is_object: * refcount_objects_in_slice(self.data, self._shape, self._strides, self.ndim, inc=False) */ } __pyx_L3:; /* "View.MemoryView":217 * refcount_objects_in_slice(self.data, self._shape, self._strides, self.ndim, inc=False) * free(self.data) * PyObject_Free(self._shape) # <<<<<<<<<<<<<< * * @property */ PyObject_Free(__pyx_v_self->_shape); /* "View.MemoryView":210 * info.obj = self * * def __dealloc__(array self): # <<<<<<<<<<<<<< * if self.callback_free_data != NULL: * self.callback_free_data(self.data) */ /* function exit code */ } /* "View.MemoryView":219 * PyObject_Free(self._shape) * * @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) { CYTHON_UNUSED PyObject *const *__pyx_kwvalues; PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__get__ (wrapper)", 0); __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs); __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__", 1); /* "View.MemoryView":221 * @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, 221, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_r = __pyx_t_1; __pyx_t_1 = 0; goto __pyx_L0; /* "View.MemoryView":219 * PyObject_Free(self._shape) * * @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":224 * * @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", 1); /* "View.MemoryView":225 * @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":226 * 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, 226, __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, 226, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __pyx_t_3 = PyTuple_New(3); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 226, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __Pyx_INCREF((PyObject *)__pyx_v_self); __Pyx_GIVEREF((PyObject *)__pyx_v_self); if (__Pyx_PyTuple_SET_ITEM(__pyx_t_3, 0, ((PyObject *)__pyx_v_self))) __PYX_ERR(1, 226, __pyx_L1_error); __Pyx_GIVEREF(__pyx_t_1); if (__Pyx_PyTuple_SET_ITEM(__pyx_t_3, 1, __pyx_t_1)) __PYX_ERR(1, 226, __pyx_L1_error); __Pyx_GIVEREF(__pyx_t_2); if (__Pyx_PyTuple_SET_ITEM(__pyx_t_3, 2, __pyx_t_2)) __PYX_ERR(1, 226, __pyx_L1_error); __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, 226, __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":224 * * @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":228 * 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) { CYTHON_UNUSED PyObject *const *__pyx_kwvalues; Py_ssize_t __pyx_r; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__len__ (wrapper)", 0); __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs); __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; /* "View.MemoryView":229 * * def __len__(self): * return self._shape[0] # <<<<<<<<<<<<<< * * def __getattr__(self, attr): */ __pyx_r = (__pyx_v_self->_shape[0]); goto __pyx_L0; /* "View.MemoryView":228 * return memoryview(self, flags, self.dtype_is_object) * * def __len__(self): # <<<<<<<<<<<<<< * return self._shape[0] * */ /* function exit code */ __pyx_L0:; return __pyx_r; } /* "View.MemoryView":231 * 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) { CYTHON_UNUSED PyObject *const *__pyx_kwvalues; PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__getattr__ (wrapper)", 0); __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs); __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__", 1); /* "View.MemoryView":232 * * 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, 232, __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, 232, __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":231 * 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":234 * 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) { CYTHON_UNUSED PyObject *const *__pyx_kwvalues; PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__getitem__ (wrapper)", 0); __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs); __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__", 1); /* "View.MemoryView":235 * * 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, 235, __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, 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 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":237 * 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) { CYTHON_UNUSED PyObject *const *__pyx_kwvalues; int __pyx_r; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__setitem__ (wrapper)", 0); __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs); __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__", 1); /* "View.MemoryView":238 * * 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, 238, __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, 238, __pyx_L1_error) __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; /* "View.MemoryView":237 * 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, #if CYTHON_METH_FASTCALL PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds #else PyObject *__pyx_args, PyObject *__pyx_kwds #endif ); /*proto*/ static PyObject *__pyx_pw___pyx_array_1__reduce_cython__(PyObject *__pyx_v_self, #if CYTHON_METH_FASTCALL PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds #else PyObject *__pyx_args, PyObject *__pyx_kwds #endif ) { #if !CYTHON_METH_FASTCALL CYTHON_UNUSED Py_ssize_t __pyx_nargs; #endif CYTHON_UNUSED PyObject *const *__pyx_kwvalues; PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__reduce_cython__ (wrapper)", 0); #if !CYTHON_METH_FASTCALL #if CYTHON_ASSUME_SAFE_MACROS __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); #else __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; #endif #endif __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); if (unlikely(__pyx_nargs > 0)) { __Pyx_RaiseArgtupleInvalid("__reduce_cython__", 1, 0, 0, __pyx_nargs); return NULL;} if (unlikely(__pyx_kwds) && __Pyx_NumKwargs_FASTCALL(__pyx_kwds) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "__reduce_cython__", 0))) return NULL; __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 int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("__reduce_cython__", 1); /* "(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_Raise(__pyx_builtin_TypeError, __pyx_kp_s_no_default___reduce___due_to_non, 0, 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_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, #if CYTHON_METH_FASTCALL PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds #else PyObject *__pyx_args, PyObject *__pyx_kwds #endif ); /*proto*/ static PyObject *__pyx_pw___pyx_array_3__setstate_cython__(PyObject *__pyx_v_self, #if CYTHON_METH_FASTCALL PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds #else PyObject *__pyx_args, PyObject *__pyx_kwds #endif ) { CYTHON_UNUSED PyObject *__pyx_v___pyx_state = 0; #if !CYTHON_METH_FASTCALL CYTHON_UNUSED Py_ssize_t __pyx_nargs; #endif CYTHON_UNUSED PyObject *const *__pyx_kwvalues; PyObject* values[1] = {0}; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__setstate_cython__ (wrapper)", 0); #if !CYTHON_METH_FASTCALL #if CYTHON_ASSUME_SAFE_MACROS __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); #else __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; #endif #endif __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); { PyObject **__pyx_pyargnames[] = {&__pyx_n_s_pyx_state,0}; if (__pyx_kwds) { Py_ssize_t kw_args; switch (__pyx_nargs) { case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); CYTHON_FALLTHROUGH; case 0: break; default: goto __pyx_L5_argtuple_error; } kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); switch (__pyx_nargs) { case 0: if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_pyx_state)) != 0)) { (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); kw_args--; } else if (unlikely(PyErr_Occurred())) __PYX_ERR(1, 3, __pyx_L3_error) else goto __pyx_L5_argtuple_error; } if (unlikely(kw_args > 0)) { const Py_ssize_t kwd_pos_args = __pyx_nargs; if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "__setstate_cython__") < 0)) __PYX_ERR(1, 3, __pyx_L3_error) } } else if (unlikely(__pyx_nargs != 1)) { goto __pyx_L5_argtuple_error; } else { values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); } __pyx_v___pyx_state = values[0]; } goto __pyx_L6_skip; __pyx_L5_argtuple_error:; __Pyx_RaiseArgtupleInvalid("__setstate_cython__", 1, 1, 1, __pyx_nargs); __PYX_ERR(1, 3, __pyx_L3_error) __pyx_L6_skip:; goto __pyx_L4_argument_unpacking_done; __pyx_L3_error:; { Py_ssize_t __pyx_temp; for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); } } __Pyx_AddTraceback("View.MemoryView.array.__setstate_cython__", __pyx_clineno, __pyx_lineno, __pyx_filename); __Pyx_RefNannyFinishContext(); return NULL; __pyx_L4_argument_unpacking_done:; __pyx_r = __pyx_pf___pyx_array_2__setstate_cython__(((struct __pyx_array_obj *)__pyx_v_self), __pyx_v___pyx_state); /* function exit code */ { Py_ssize_t __pyx_temp; for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); } } __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 int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("__setstate_cython__", 1); /* "(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_Raise(__pyx_builtin_TypeError, __pyx_kp_s_no_default___reduce___due_to_non, 0, 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_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":248 * * @cname("__pyx_array_allocate_buffer") * cdef int _allocate_buffer(array self) except -1: # <<<<<<<<<<<<<< * * */ static int __pyx_array_allocate_buffer(struct __pyx_array_obj *__pyx_v_self) { Py_ssize_t __pyx_v_i; PyObject **__pyx_v_p; int __pyx_r; int __pyx_t_1; Py_ssize_t __pyx_t_2; Py_ssize_t __pyx_t_3; Py_ssize_t __pyx_t_4; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; /* "View.MemoryView":254 * cdef PyObject **p * * self.free_data = True # <<<<<<<<<<<<<< * self.data = malloc(self.len) * if not self.data: */ __pyx_v_self->free_data = 1; /* "View.MemoryView":255 * * self.free_data = True * 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":256 * self.free_data = True * self.data = malloc(self.len) * if not self.data: # <<<<<<<<<<<<<< * raise MemoryError, "unable to allocate array data." * */ __pyx_t_1 = (!(__pyx_v_self->data != 0)); if (unlikely(__pyx_t_1)) { /* "View.MemoryView":257 * self.data = malloc(self.len) * if not self.data: * raise MemoryError, "unable to allocate array data." # <<<<<<<<<<<<<< * * if self.dtype_is_object: */ __Pyx_Raise(__pyx_builtin_MemoryError, __pyx_kp_s_unable_to_allocate_array_data, 0, 0); __PYX_ERR(1, 257, __pyx_L1_error) /* "View.MemoryView":256 * self.free_data = True * self.data = malloc(self.len) * if not self.data: # <<<<<<<<<<<<<< * raise MemoryError, "unable to allocate array data." * */ } /* "View.MemoryView":259 * raise MemoryError, "unable to allocate array data." * * if self.dtype_is_object: # <<<<<<<<<<<<<< * p = self.data * for i in range(self.len // self.itemsize): */ if (__pyx_v_self->dtype_is_object) { /* "View.MemoryView":260 * * if self.dtype_is_object: * p = self.data # <<<<<<<<<<<<<< * for i in range(self.len // self.itemsize): * p[i] = Py_None */ __pyx_v_p = ((PyObject **)__pyx_v_self->data); /* "View.MemoryView":261 * if self.dtype_is_object: * p = self.data * for i in range(self.len // self.itemsize): # <<<<<<<<<<<<<< * p[i] = Py_None * Py_INCREF(Py_None) */ if (unlikely(__pyx_v_self->itemsize == 0)) { PyErr_SetString(PyExc_ZeroDivisionError, "integer division or modulo by zero"); __PYX_ERR(1, 261, __pyx_L1_error) } else if (sizeof(Py_ssize_t) == sizeof(long) && (!(((Py_ssize_t)-1) > 0)) && unlikely(__pyx_v_self->itemsize == (Py_ssize_t)-1) && unlikely(__Pyx_UNARY_NEG_WOULD_OVERFLOW(__pyx_v_self->len))) { PyErr_SetString(PyExc_OverflowError, "value too large to perform division"); __PYX_ERR(1, 261, __pyx_L1_error) } __pyx_t_2 = __Pyx_div_Py_ssize_t(__pyx_v_self->len, __pyx_v_self->itemsize); __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":262 * p = self.data * for i in range(self.len // self.itemsize): * p[i] = Py_None # <<<<<<<<<<<<<< * Py_INCREF(Py_None) * return 0 */ (__pyx_v_p[__pyx_v_i]) = Py_None; /* "View.MemoryView":263 * for i in range(self.len // self.itemsize): * p[i] = Py_None * Py_INCREF(Py_None) # <<<<<<<<<<<<<< * return 0 * */ Py_INCREF(Py_None); } /* "View.MemoryView":259 * raise MemoryError, "unable to allocate array data." * * if self.dtype_is_object: # <<<<<<<<<<<<<< * p = self.data * for i in range(self.len // self.itemsize): */ } /* "View.MemoryView":264 * p[i] = Py_None * Py_INCREF(Py_None) * return 0 # <<<<<<<<<<<<<< * * */ __pyx_r = 0; goto __pyx_L0; /* "View.MemoryView":248 * * @cname("__pyx_array_allocate_buffer") * cdef int _allocate_buffer(array self) except -1: # <<<<<<<<<<<<<< * * */ /* function exit code */ __pyx_L1_error:; __Pyx_AddTraceback("View.MemoryView._allocate_buffer", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = -1; __pyx_L0:; return __pyx_r; } /* "View.MemoryView":268 * * @cname("__pyx_array_new") * cdef array array_cwrapper(tuple shape, Py_ssize_t itemsize, char *format, char *c_mode, char *buf): # <<<<<<<<<<<<<< * cdef array result * cdef str mode = "fortran" if c_mode[0] == b'f' else "c" # this often comes from a constant C string. */ 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_c_mode, char *__pyx_v_buf) { struct __pyx_array_obj *__pyx_v_result = 0; PyObject *__pyx_v_mode = 0; struct __pyx_array_obj *__pyx_r = NULL; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; 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("array_cwrapper", 1); /* "View.MemoryView":270 * cdef array array_cwrapper(tuple shape, Py_ssize_t itemsize, char *format, char *c_mode, char *buf): * cdef array result * cdef str mode = "fortran" if c_mode[0] == b'f' else "c" # this often comes from a constant C string. # <<<<<<<<<<<<<< * * if buf is NULL: */ __pyx_t_2 = ((__pyx_v_c_mode[0]) == 'f'); if (__pyx_t_2) { __Pyx_INCREF(__pyx_n_s_fortran); __pyx_t_1 = __pyx_n_s_fortran; } else { __Pyx_INCREF(__pyx_n_s_c); __pyx_t_1 = __pyx_n_s_c; } __pyx_v_mode = ((PyObject*)__pyx_t_1); __pyx_t_1 = 0; /* "View.MemoryView":272 * cdef str mode = "fortran" if c_mode[0] == b'f' else "c" # this often comes from a constant C string. * * if buf is NULL: # <<<<<<<<<<<<<< * result = array.__new__(array, shape, itemsize, format, mode) * else: */ __pyx_t_2 = (__pyx_v_buf == NULL); if (__pyx_t_2) { /* "View.MemoryView":273 * * if buf is NULL: * result = array.__new__(array, shape, itemsize, format, mode) # <<<<<<<<<<<<<< * else: * result = array.__new__(array, shape, itemsize, format, mode, allocate_buffer=False) */ __pyx_t_1 = PyInt_FromSsize_t(__pyx_v_itemsize); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 273, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_t_3 = __Pyx_PyBytes_FromString(__pyx_v_format); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 273, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __pyx_t_4 = PyTuple_New(4); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 273, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __Pyx_INCREF(__pyx_v_shape); __Pyx_GIVEREF(__pyx_v_shape); if (__Pyx_PyTuple_SET_ITEM(__pyx_t_4, 0, __pyx_v_shape)) __PYX_ERR(1, 273, __pyx_L1_error); __Pyx_GIVEREF(__pyx_t_1); if (__Pyx_PyTuple_SET_ITEM(__pyx_t_4, 1, __pyx_t_1)) __PYX_ERR(1, 273, __pyx_L1_error); __Pyx_GIVEREF(__pyx_t_3); if (__Pyx_PyTuple_SET_ITEM(__pyx_t_4, 2, __pyx_t_3)) __PYX_ERR(1, 273, __pyx_L1_error); __Pyx_INCREF(__pyx_v_mode); __Pyx_GIVEREF(__pyx_v_mode); if (__Pyx_PyTuple_SET_ITEM(__pyx_t_4, 3, __pyx_v_mode)) __PYX_ERR(1, 273, __pyx_L1_error); __pyx_t_1 = 0; __pyx_t_3 = 0; __pyx_t_3 = ((PyObject *)__pyx_tp_new_array(((PyTypeObject *)__pyx_array_type), __pyx_t_4, NULL)); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 273, __pyx_L1_error) __Pyx_GOTREF((PyObject *)__pyx_t_3); __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __pyx_v_result = ((struct __pyx_array_obj *)__pyx_t_3); __pyx_t_3 = 0; /* "View.MemoryView":272 * cdef str mode = "fortran" if c_mode[0] == b'f' else "c" # this often comes from a constant C string. * * if buf is NULL: # <<<<<<<<<<<<<< * result = array.__new__(array, shape, itemsize, format, mode) * else: */ goto __pyx_L3; } /* "View.MemoryView":275 * result = array.__new__(array, shape, itemsize, format, mode) * else: * result = array.__new__(array, shape, itemsize, format, mode, allocate_buffer=False) # <<<<<<<<<<<<<< * result.data = buf * */ /*else*/ { __pyx_t_3 = PyInt_FromSsize_t(__pyx_v_itemsize); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 275, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __pyx_t_4 = __Pyx_PyBytes_FromString(__pyx_v_format); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 275, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __pyx_t_1 = PyTuple_New(4); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 275, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_INCREF(__pyx_v_shape); __Pyx_GIVEREF(__pyx_v_shape); if (__Pyx_PyTuple_SET_ITEM(__pyx_t_1, 0, __pyx_v_shape)) __PYX_ERR(1, 275, __pyx_L1_error); __Pyx_GIVEREF(__pyx_t_3); if (__Pyx_PyTuple_SET_ITEM(__pyx_t_1, 1, __pyx_t_3)) __PYX_ERR(1, 275, __pyx_L1_error); __Pyx_GIVEREF(__pyx_t_4); if (__Pyx_PyTuple_SET_ITEM(__pyx_t_1, 2, __pyx_t_4)) __PYX_ERR(1, 275, __pyx_L1_error); __Pyx_INCREF(__pyx_v_mode); __Pyx_GIVEREF(__pyx_v_mode); if (__Pyx_PyTuple_SET_ITEM(__pyx_t_1, 3, __pyx_v_mode)) __PYX_ERR(1, 275, __pyx_L1_error); __pyx_t_3 = 0; __pyx_t_4 = 0; __pyx_t_4 = __Pyx_PyDict_NewPresized(1); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 275, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); if (PyDict_SetItem(__pyx_t_4, __pyx_n_s_allocate_buffer, Py_False) < 0) __PYX_ERR(1, 275, __pyx_L1_error) __pyx_t_3 = ((PyObject *)__pyx_tp_new_array(((PyTypeObject *)__pyx_array_type), __pyx_t_1, __pyx_t_4)); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 275, __pyx_L1_error) __Pyx_GOTREF((PyObject *)__pyx_t_3); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __pyx_v_result = ((struct __pyx_array_obj *)__pyx_t_3); __pyx_t_3 = 0; /* "View.MemoryView":276 * else: * result = array.__new__(array, shape, itemsize, format, mode, allocate_buffer=False) * result.data = buf # <<<<<<<<<<<<<< * * return result */ __pyx_v_result->data = __pyx_v_buf; } __pyx_L3:; /* "View.MemoryView":278 * 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":268 * * @cname("__pyx_array_new") * cdef array array_cwrapper(tuple shape, Py_ssize_t itemsize, char *format, char *c_mode, char *buf): # <<<<<<<<<<<<<< * cdef array result * cdef str mode = "fortran" if c_mode[0] == b'f' else "c" # this often comes from a constant C string. */ /* function exit code */ __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_1); __Pyx_XDECREF(__pyx_t_3); __Pyx_XDECREF(__pyx_t_4); __Pyx_AddTraceback("View.MemoryView.array_cwrapper", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = 0; __pyx_L0:; __Pyx_XDECREF((PyObject *)__pyx_v_result); __Pyx_XDECREF(__pyx_v_mode); __Pyx_XGIVEREF((PyObject *)__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "View.MemoryView":304 * 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; CYTHON_UNUSED Py_ssize_t __pyx_nargs; CYTHON_UNUSED PyObject *const *__pyx_kwvalues; PyObject* values[1] = {0}; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; int __pyx_r; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__init__ (wrapper)", 0); #if CYTHON_ASSUME_SAFE_MACROS __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); #else __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return -1; #endif __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs); { PyObject **__pyx_pyargnames[] = {&__pyx_n_s_name,0}; if (__pyx_kwds) { Py_ssize_t kw_args; switch (__pyx_nargs) { case 1: values[0] = __Pyx_Arg_VARARGS(__pyx_args, 0); CYTHON_FALLTHROUGH; case 0: break; default: goto __pyx_L5_argtuple_error; } kw_args = __Pyx_NumKwargs_VARARGS(__pyx_kwds); switch (__pyx_nargs) { case 0: if (likely((values[0] = __Pyx_GetKwValue_VARARGS(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_name)) != 0)) { (void)__Pyx_Arg_NewRef_VARARGS(values[0]); kw_args--; } else if (unlikely(PyErr_Occurred())) __PYX_ERR(1, 304, __pyx_L3_error) else goto __pyx_L5_argtuple_error; } if (unlikely(kw_args > 0)) { const Py_ssize_t kwd_pos_args = __pyx_nargs; if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "__init__") < 0)) __PYX_ERR(1, 304, __pyx_L3_error) } } else if (unlikely(__pyx_nargs != 1)) { goto __pyx_L5_argtuple_error; } else { values[0] = __Pyx_Arg_VARARGS(__pyx_args, 0); } __pyx_v_name = values[0]; } goto __pyx_L6_skip; __pyx_L5_argtuple_error:; __Pyx_RaiseArgtupleInvalid("__init__", 1, 1, 1, __pyx_nargs); __PYX_ERR(1, 304, __pyx_L3_error) __pyx_L6_skip:; goto __pyx_L4_argument_unpacking_done; __pyx_L3_error:; { Py_ssize_t __pyx_temp; for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { __Pyx_Arg_XDECREF_VARARGS(values[__pyx_temp]); } } __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 */ { Py_ssize_t __pyx_temp; for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { __Pyx_Arg_XDECREF_VARARGS(values[__pyx_temp]); } } __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__", 1); /* "View.MemoryView":305 * 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":304 * 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":306 * 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) { CYTHON_UNUSED PyObject *const *__pyx_kwvalues; PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__repr__ (wrapper)", 0); __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs); __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__", 1); /* "View.MemoryView":307 * 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":306 * 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, #if CYTHON_METH_FASTCALL PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds #else PyObject *__pyx_args, PyObject *__pyx_kwds #endif ); /*proto*/ static PyObject *__pyx_pw___pyx_MemviewEnum_1__reduce_cython__(PyObject *__pyx_v_self, #if CYTHON_METH_FASTCALL PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds #else PyObject *__pyx_args, PyObject *__pyx_kwds #endif ) { #if !CYTHON_METH_FASTCALL CYTHON_UNUSED Py_ssize_t __pyx_nargs; #endif CYTHON_UNUSED PyObject *const *__pyx_kwvalues; PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__reduce_cython__ (wrapper)", 0); #if !CYTHON_METH_FASTCALL #if CYTHON_ASSUME_SAFE_MACROS __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); #else __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; #endif #endif __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); if (unlikely(__pyx_nargs > 0)) { __Pyx_RaiseArgtupleInvalid("__reduce_cython__", 1, 0, 0, __pyx_nargs); return NULL;} if (unlikely(__pyx_kwds) && __Pyx_NumKwargs_FASTCALL(__pyx_kwds) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "__reduce_cython__", 0))) return NULL; __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; 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("__reduce_cython__", 1); /* "(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); if (__Pyx_PyTuple_SET_ITEM(__pyx_t_1, 0, __pyx_v_self->name)) __PYX_ERR(1, 5, __pyx_L1_error); __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); if (__pyx_t_2) { /* "(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); if (__Pyx_PyTuple_SET_ITEM(__pyx_t_1, 0, __pyx_v__dict)) __PYX_ERR(1, 8, __pyx_L1_error); __pyx_t_3 = PyNumber_InPlaceAdd(__pyx_v_state, __pyx_t_1); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 8, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __Pyx_DECREF_SET(__pyx_v_state, ((PyObject*)__pyx_t_3)); __pyx_t_3 = 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), 0x82a3537, None), state */ /*else*/ { __pyx_t_2 = (__pyx_v_self->name != Py_None); __pyx_v_use_setstate = __pyx_t_2; } __pyx_L3:; /* "(tree fragment)":12 * else: * use_setstate = self.name is not None * if use_setstate: # <<<<<<<<<<<<<< * return __pyx_unpickle_Enum, (type(self), 0x82a3537, None), state * else: */ if (__pyx_v_use_setstate) { /* "(tree fragment)":13 * use_setstate = self.name is not None * if use_setstate: * return __pyx_unpickle_Enum, (type(self), 0x82a3537, None), state # <<<<<<<<<<<<<< * else: * return __pyx_unpickle_Enum, (type(self), 0x82a3537, state) */ __Pyx_XDECREF(__pyx_r); __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_n_s_pyx_unpickle_Enum); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 13, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __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)))); if (__Pyx_PyTuple_SET_ITEM(__pyx_t_1, 0, ((PyObject *)Py_TYPE(((PyObject *)__pyx_v_self))))) __PYX_ERR(1, 13, __pyx_L1_error); __Pyx_INCREF(__pyx_int_136983863); __Pyx_GIVEREF(__pyx_int_136983863); if (__Pyx_PyTuple_SET_ITEM(__pyx_t_1, 1, __pyx_int_136983863)) __PYX_ERR(1, 13, __pyx_L1_error); __Pyx_INCREF(Py_None); __Pyx_GIVEREF(Py_None); if (__Pyx_PyTuple_SET_ITEM(__pyx_t_1, 2, Py_None)) __PYX_ERR(1, 13, __pyx_L1_error); __pyx_t_4 = PyTuple_New(3); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 13, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __Pyx_GIVEREF(__pyx_t_3); if (__Pyx_PyTuple_SET_ITEM(__pyx_t_4, 0, __pyx_t_3)) __PYX_ERR(1, 13, __pyx_L1_error); __Pyx_GIVEREF(__pyx_t_1); if (__Pyx_PyTuple_SET_ITEM(__pyx_t_4, 1, __pyx_t_1)) __PYX_ERR(1, 13, __pyx_L1_error); __Pyx_INCREF(__pyx_v_state); __Pyx_GIVEREF(__pyx_v_state); if (__Pyx_PyTuple_SET_ITEM(__pyx_t_4, 2, __pyx_v_state)) __PYX_ERR(1, 13, __pyx_L1_error); __pyx_t_3 = 0; __pyx_t_1 = 0; __pyx_r = __pyx_t_4; __pyx_t_4 = 0; goto __pyx_L0; /* "(tree fragment)":12 * else: * use_setstate = self.name is not None * if use_setstate: # <<<<<<<<<<<<<< * return __pyx_unpickle_Enum, (type(self), 0x82a3537, None), state * else: */ } /* "(tree fragment)":15 * return __pyx_unpickle_Enum, (type(self), 0x82a3537, None), state * else: * return __pyx_unpickle_Enum, (type(self), 0x82a3537, state) # <<<<<<<<<<<<<< * def __setstate_cython__(self, __pyx_state): * __pyx_unpickle_Enum__set_state(self, __pyx_state) */ /*else*/ { __Pyx_XDECREF(__pyx_r); __Pyx_GetModuleGlobalName(__pyx_t_4, __pyx_n_s_pyx_unpickle_Enum); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 15, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __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)))); if (__Pyx_PyTuple_SET_ITEM(__pyx_t_1, 0, ((PyObject *)Py_TYPE(((PyObject *)__pyx_v_self))))) __PYX_ERR(1, 15, __pyx_L1_error); __Pyx_INCREF(__pyx_int_136983863); __Pyx_GIVEREF(__pyx_int_136983863); if (__Pyx_PyTuple_SET_ITEM(__pyx_t_1, 1, __pyx_int_136983863)) __PYX_ERR(1, 15, __pyx_L1_error); __Pyx_INCREF(__pyx_v_state); __Pyx_GIVEREF(__pyx_v_state); if (__Pyx_PyTuple_SET_ITEM(__pyx_t_1, 2, __pyx_v_state)) __PYX_ERR(1, 15, __pyx_L1_error); __pyx_t_3 = PyTuple_New(2); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 15, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __Pyx_GIVEREF(__pyx_t_4); if (__Pyx_PyTuple_SET_ITEM(__pyx_t_3, 0, __pyx_t_4)) __PYX_ERR(1, 15, __pyx_L1_error); __Pyx_GIVEREF(__pyx_t_1); if (__Pyx_PyTuple_SET_ITEM(__pyx_t_3, 1, __pyx_t_1)) __PYX_ERR(1, 15, __pyx_L1_error); __pyx_t_4 = 0; __pyx_t_1 = 0; __pyx_r = __pyx_t_3; __pyx_t_3 = 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_3); __Pyx_XDECREF(__pyx_t_4); __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), 0x82a3537, 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, #if CYTHON_METH_FASTCALL PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds #else PyObject *__pyx_args, PyObject *__pyx_kwds #endif ); /*proto*/ static PyObject *__pyx_pw___pyx_MemviewEnum_3__setstate_cython__(PyObject *__pyx_v_self, #if CYTHON_METH_FASTCALL PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds #else PyObject *__pyx_args, PyObject *__pyx_kwds #endif ) { PyObject *__pyx_v___pyx_state = 0; #if !CYTHON_METH_FASTCALL CYTHON_UNUSED Py_ssize_t __pyx_nargs; #endif CYTHON_UNUSED PyObject *const *__pyx_kwvalues; PyObject* values[1] = {0}; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__setstate_cython__ (wrapper)", 0); #if !CYTHON_METH_FASTCALL #if CYTHON_ASSUME_SAFE_MACROS __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); #else __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; #endif #endif __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); { PyObject **__pyx_pyargnames[] = {&__pyx_n_s_pyx_state,0}; if (__pyx_kwds) { Py_ssize_t kw_args; switch (__pyx_nargs) { case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); CYTHON_FALLTHROUGH; case 0: break; default: goto __pyx_L5_argtuple_error; } kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); switch (__pyx_nargs) { case 0: if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_pyx_state)) != 0)) { (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); kw_args--; } else if (unlikely(PyErr_Occurred())) __PYX_ERR(1, 16, __pyx_L3_error) else goto __pyx_L5_argtuple_error; } if (unlikely(kw_args > 0)) { const Py_ssize_t kwd_pos_args = __pyx_nargs; if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "__setstate_cython__") < 0)) __PYX_ERR(1, 16, __pyx_L3_error) } } else if (unlikely(__pyx_nargs != 1)) { goto __pyx_L5_argtuple_error; } else { values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); } __pyx_v___pyx_state = values[0]; } goto __pyx_L6_skip; __pyx_L5_argtuple_error:; __Pyx_RaiseArgtupleInvalid("__setstate_cython__", 1, 1, 1, __pyx_nargs); __PYX_ERR(1, 16, __pyx_L3_error) __pyx_L6_skip:; goto __pyx_L4_argument_unpacking_done; __pyx_L3_error:; { Py_ssize_t __pyx_temp; for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); } } __Pyx_AddTraceback("View.MemoryView.Enum.__setstate_cython__", __pyx_clineno, __pyx_lineno, __pyx_filename); __Pyx_RefNannyFinishContext(); return NULL; __pyx_L4_argument_unpacking_done:; __pyx_r = __pyx_pf___pyx_MemviewEnum_2__setstate_cython__(((struct __pyx_MemviewEnum_obj *)__pyx_v_self), __pyx_v___pyx_state); /* function exit code */ { Py_ssize_t __pyx_temp; for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); } } __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__", 1); /* "(tree fragment)":17 * return __pyx_unpickle_Enum, (type(self), 0x82a3537, 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) || __Pyx_RaiseUnexpectedTypeError("tuple", __pyx_v___pyx_state))) __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), 0x82a3537, 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":349 * 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; CYTHON_UNUSED Py_ssize_t __pyx_nargs; CYTHON_UNUSED PyObject *const *__pyx_kwvalues; PyObject* values[3] = {0,0,0}; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; int __pyx_r; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__cinit__ (wrapper)", 0); #if CYTHON_ASSUME_SAFE_MACROS __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); #else __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return -1; #endif __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs); { PyObject **__pyx_pyargnames[] = {&__pyx_n_s_obj,&__pyx_n_s_flags,&__pyx_n_s_dtype_is_object,0}; if (__pyx_kwds) { Py_ssize_t kw_args; switch (__pyx_nargs) { case 3: values[2] = __Pyx_Arg_VARARGS(__pyx_args, 2); CYTHON_FALLTHROUGH; case 2: values[1] = __Pyx_Arg_VARARGS(__pyx_args, 1); CYTHON_FALLTHROUGH; case 1: values[0] = __Pyx_Arg_VARARGS(__pyx_args, 0); CYTHON_FALLTHROUGH; case 0: break; default: goto __pyx_L5_argtuple_error; } kw_args = __Pyx_NumKwargs_VARARGS(__pyx_kwds); switch (__pyx_nargs) { case 0: if (likely((values[0] = __Pyx_GetKwValue_VARARGS(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_obj)) != 0)) { (void)__Pyx_Arg_NewRef_VARARGS(values[0]); kw_args--; } else if (unlikely(PyErr_Occurred())) __PYX_ERR(1, 349, __pyx_L3_error) else goto __pyx_L5_argtuple_error; CYTHON_FALLTHROUGH; case 1: if (likely((values[1] = __Pyx_GetKwValue_VARARGS(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_flags)) != 0)) { (void)__Pyx_Arg_NewRef_VARARGS(values[1]); kw_args--; } else if (unlikely(PyErr_Occurred())) __PYX_ERR(1, 349, __pyx_L3_error) else { __Pyx_RaiseArgtupleInvalid("__cinit__", 0, 2, 3, 1); __PYX_ERR(1, 349, __pyx_L3_error) } CYTHON_FALLTHROUGH; case 2: if (kw_args > 0) { PyObject* value = __Pyx_GetKwValue_VARARGS(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_dtype_is_object); if (value) { values[2] = __Pyx_Arg_NewRef_VARARGS(value); kw_args--; } else if (unlikely(PyErr_Occurred())) __PYX_ERR(1, 349, __pyx_L3_error) } } if (unlikely(kw_args > 0)) { const Py_ssize_t kwd_pos_args = __pyx_nargs; if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "__cinit__") < 0)) __PYX_ERR(1, 349, __pyx_L3_error) } } else { switch (__pyx_nargs) { case 3: values[2] = __Pyx_Arg_VARARGS(__pyx_args, 2); CYTHON_FALLTHROUGH; case 2: values[1] = __Pyx_Arg_VARARGS(__pyx_args, 1); values[0] = __Pyx_Arg_VARARGS(__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, 349, __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, 349, __pyx_L3_error) } else { __pyx_v_dtype_is_object = ((int)0); } } goto __pyx_L6_skip; __pyx_L5_argtuple_error:; __Pyx_RaiseArgtupleInvalid("__cinit__", 0, 2, 3, __pyx_nargs); __PYX_ERR(1, 349, __pyx_L3_error) __pyx_L6_skip:; goto __pyx_L4_argument_unpacking_done; __pyx_L3_error:; { Py_ssize_t __pyx_temp; for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { __Pyx_Arg_XDECREF_VARARGS(values[__pyx_temp]); } } __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 */ { Py_ssize_t __pyx_temp; for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { __Pyx_Arg_XDECREF_VARARGS(values[__pyx_temp]); } } __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; Py_intptr_t __pyx_t_4; size_t __pyx_t_5; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("__cinit__", 1); /* "View.MemoryView":350 * * 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":351 * 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":352 * 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)); if (!__pyx_t_2) { } else { __pyx_t_1 = __pyx_t_2; goto __pyx_L4_bool_binop_done; } __pyx_t_2 = (__pyx_v_obj != Py_None); __pyx_t_1 = __pyx_t_2; __pyx_L4_bool_binop_done:; if (__pyx_t_1) { /* "View.MemoryView":353 * 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_3 = __Pyx_GetBuffer(__pyx_v_obj, (&__pyx_v_self->view), __pyx_v_flags); if (unlikely(__pyx_t_3 == ((int)-1))) __PYX_ERR(1, 353, __pyx_L1_error) /* "View.MemoryView":354 * 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); if (__pyx_t_1) { /* "View.MemoryView":355 * __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":356 * 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":354 * 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":352 * 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":358 * Py_INCREF(Py_None) * * if not __PYX_CYTHON_ATOMICS_ENABLED(): # <<<<<<<<<<<<<< * global __pyx_memoryview_thread_locks_used * if __pyx_memoryview_thread_locks_used < 8: */ __pyx_t_1 = (!__PYX_CYTHON_ATOMICS_ENABLED()); if (__pyx_t_1) { /* "View.MemoryView":360 * if not __PYX_CYTHON_ATOMICS_ENABLED(): * global __pyx_memoryview_thread_locks_used * if __pyx_memoryview_thread_locks_used < 8: # <<<<<<<<<<<<<< * 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); if (__pyx_t_1) { /* "View.MemoryView":361 * global __pyx_memoryview_thread_locks_used * if __pyx_memoryview_thread_locks_used < 8: * 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":362 * if __pyx_memoryview_thread_locks_used < 8: * 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":360 * if not __PYX_CYTHON_ATOMICS_ENABLED(): * global __pyx_memoryview_thread_locks_used * if __pyx_memoryview_thread_locks_used < 8: # <<<<<<<<<<<<<< * self.lock = __pyx_memoryview_thread_locks[__pyx_memoryview_thread_locks_used] * __pyx_memoryview_thread_locks_used += 1 */ } /* "View.MemoryView":363 * 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); if (__pyx_t_1) { /* "View.MemoryView":364 * __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":365 * 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); if (unlikely(__pyx_t_1)) { /* "View.MemoryView":366 * self.lock = PyThread_allocate_lock() * if self.lock is NULL: * raise MemoryError # <<<<<<<<<<<<<< * * if flags & PyBUF_FORMAT: */ PyErr_NoMemory(); __PYX_ERR(1, 366, __pyx_L1_error) /* "View.MemoryView":365 * if self.lock is NULL: * self.lock = PyThread_allocate_lock() * if self.lock is NULL: # <<<<<<<<<<<<<< * raise MemoryError * */ } /* "View.MemoryView":363 * 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":358 * Py_INCREF(Py_None) * * if not __PYX_CYTHON_ATOMICS_ENABLED(): # <<<<<<<<<<<<<< * global __pyx_memoryview_thread_locks_used * if __pyx_memoryview_thread_locks_used < 8: */ } /* "View.MemoryView":368 * 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":369 * * 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'); 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'); __pyx_t_1 = __pyx_t_2; __pyx_L12_bool_binop_done:; __pyx_v_self->dtype_is_object = __pyx_t_1; /* "View.MemoryView":368 * 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":371 * 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 # <<<<<<<<<<<<<< * * assert (&self.acquisition_count) % sizeof(__pyx_atomic_int_type) == 0 */ /*else*/ { __pyx_v_self->dtype_is_object = __pyx_v_dtype_is_object; } __pyx_L11:; /* "View.MemoryView":373 * self.dtype_is_object = dtype_is_object * * assert (&self.acquisition_count) % sizeof(__pyx_atomic_int_type) == 0 # <<<<<<<<<<<<<< * self.typeinfo = NULL * */ #ifndef CYTHON_WITHOUT_ASSERTIONS if (unlikely(__pyx_assertions_enabled())) { __pyx_t_4 = ((Py_intptr_t)((void *)(&__pyx_v_self->acquisition_count))); __pyx_t_5 = (sizeof(__pyx_atomic_int_type)); if (unlikely(__pyx_t_5 == 0)) { PyErr_SetString(PyExc_ZeroDivisionError, "integer division or modulo by zero"); __PYX_ERR(1, 373, __pyx_L1_error) } __pyx_t_1 = ((__pyx_t_4 % __pyx_t_5) == 0); if (unlikely(!__pyx_t_1)) { __Pyx_Raise(__pyx_builtin_AssertionError, 0, 0, 0); __PYX_ERR(1, 373, __pyx_L1_error) } } #else if ((1)); else __PYX_ERR(1, 373, __pyx_L1_error) #endif /* "View.MemoryView":374 * * assert (&self.acquisition_count) % sizeof(__pyx_atomic_int_type) == 0 * self.typeinfo = NULL # <<<<<<<<<<<<<< * * def __dealloc__(memoryview self): */ __pyx_v_self->typeinfo = NULL; /* "View.MemoryView":349 * 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":376 * 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) { CYTHON_UNUSED PyObject *const *__pyx_kwvalues; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__dealloc__ (wrapper)", 0); __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs); __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; int __pyx_t_1; int __pyx_t_2; int __pyx_t_3; int __pyx_t_4; PyThread_type_lock __pyx_t_5; PyThread_type_lock __pyx_t_6; /* "View.MemoryView":377 * * 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); if (__pyx_t_1) { /* "View.MemoryView":378 * 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":377 * * 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":379 * 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_1 = (((Py_buffer *)(&__pyx_v_self->view))->obj == Py_None); if (__pyx_t_1) { /* "View.MemoryView":381 * 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":382 * * (<__pyx_buffer *> &self.view).obj = NULL * Py_DECREF(Py_None) # <<<<<<<<<<<<<< * * cdef int i */ Py_DECREF(Py_None); /* "View.MemoryView":379 * 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":386 * 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_1 = (__pyx_v_self->lock != NULL); if (__pyx_t_1) { /* "View.MemoryView":387 * 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_2 = __pyx_memoryview_thread_locks_used; __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":388 * 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_1 = ((__pyx_memoryview_thread_locks[__pyx_v_i]) == __pyx_v_self->lock); if (__pyx_t_1) { /* "View.MemoryView":389 * 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":390 * 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_1 = (__pyx_v_i != __pyx_memoryview_thread_locks_used); if (__pyx_t_1) { /* "View.MemoryView":392 * 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_5 = (__pyx_memoryview_thread_locks[__pyx_memoryview_thread_locks_used]); __pyx_t_6 = (__pyx_memoryview_thread_locks[__pyx_v_i]); /* "View.MemoryView":391 * __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_5; (__pyx_memoryview_thread_locks[__pyx_memoryview_thread_locks_used]) = __pyx_t_6; /* "View.MemoryView":390 * 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":393 * __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":388 * 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":395 * 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":386 * 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":376 * self.typeinfo = NULL * * def __dealloc__(memoryview self): # <<<<<<<<<<<<<< * if self.obj is not None: * __Pyx_ReleaseBuffer(&self.view) */ /* function exit code */ } /* "View.MemoryView":397 * 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", 1); /* "View.MemoryView":399 * 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":401 * 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, 401, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __pyx_t_4 = __Pyx_PyObject_GetIterNextFunc(__pyx_t_2); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 401, __pyx_L1_error) } for (;;) { if (likely(!__pyx_t_4)) { if (likely(PyList_CheckExact(__pyx_t_2))) { { Py_ssize_t __pyx_temp = __Pyx_PyList_GET_SIZE(__pyx_t_2); #if !CYTHON_ASSUME_SAFE_MACROS if (unlikely((__pyx_temp < 0))) __PYX_ERR(1, 401, __pyx_L1_error) #endif if (__pyx_t_3 >= __pyx_temp) 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, 401, __pyx_L1_error) #else __pyx_t_5 = __Pyx_PySequence_ITEM(__pyx_t_2, __pyx_t_3); __pyx_t_3++; if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 401, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_5); #endif } else { { Py_ssize_t __pyx_temp = __Pyx_PyTuple_GET_SIZE(__pyx_t_2); #if !CYTHON_ASSUME_SAFE_MACROS if (unlikely((__pyx_temp < 0))) __PYX_ERR(1, 401, __pyx_L1_error) #endif if (__pyx_t_3 >= __pyx_temp) 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, 401, __pyx_L1_error) #else __pyx_t_5 = __Pyx_PySequence_ITEM(__pyx_t_2, __pyx_t_3); __pyx_t_3++; if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 401, __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, 401, __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":402 * * 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, 402, __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, 402, __pyx_L1_error) __pyx_v_itemp = __pyx_t_7; /* "View.MemoryView":401 * 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":404 * itemp = pybuffer_index(&self.view, itemp, idx, dim) * * return itemp # <<<<<<<<<<<<<< * * */ __pyx_r = __pyx_v_itemp; goto __pyx_L0; /* "View.MemoryView":397 * 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":407 * * * 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) { CYTHON_UNUSED PyObject *const *__pyx_kwvalues; PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__getitem__ (wrapper)", 0); __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs); __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; PyObject *__pyx_t_2 = NULL; PyObject *__pyx_t_3 = NULL; PyObject *__pyx_t_4 = NULL; char *__pyx_t_5; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("__getitem__", 1); /* "View.MemoryView":408 * * def __getitem__(memoryview self, object index): * if index is Ellipsis: # <<<<<<<<<<<<<< * return self * */ __pyx_t_1 = (__pyx_v_index == __pyx_builtin_Ellipsis); if (__pyx_t_1) { /* "View.MemoryView":409 * 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":408 * * def __getitem__(memoryview self, object index): * if index is Ellipsis: # <<<<<<<<<<<<<< * return self * */ } /* "View.MemoryView":411 * return self * * have_slices, indices = _unellipsify(index, self.view.ndim) # <<<<<<<<<<<<<< * * cdef char *itemp */ __pyx_t_2 = _unellipsify(__pyx_v_index, __pyx_v_self->view.ndim); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 411, __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, 411, __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, 411, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __pyx_t_4 = PySequence_ITEM(sequence, 1); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 411, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); #endif __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; } else { __Pyx_RaiseNoneNotIterableError(); __PYX_ERR(1, 411, __pyx_L1_error) } __pyx_v_have_slices = __pyx_t_3; __pyx_t_3 = 0; __pyx_v_indices = __pyx_t_4; __pyx_t_4 = 0; /* "View.MemoryView":414 * * cdef char *itemp * if have_slices: # <<<<<<<<<<<<<< * return memview_slice(self, indices) * else: */ __pyx_t_1 = __Pyx_PyObject_IsTrue(__pyx_v_have_slices); if (unlikely((__pyx_t_1 < 0))) __PYX_ERR(1, 414, __pyx_L1_error) if (__pyx_t_1) { /* "View.MemoryView":415 * cdef char *itemp * if have_slices: * return memview_slice(self, indices) # <<<<<<<<<<<<<< * else: * itemp = self.get_item_pointer(indices) */ __Pyx_XDECREF(__pyx_r); __pyx_t_2 = ((PyObject *)__pyx_memview_slice(__pyx_v_self, __pyx_v_indices)); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 415, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __pyx_r = __pyx_t_2; __pyx_t_2 = 0; goto __pyx_L0; /* "View.MemoryView":414 * * cdef char *itemp * if have_slices: # <<<<<<<<<<<<<< * return memview_slice(self, indices) * else: */ } /* "View.MemoryView":417 * return memview_slice(self, indices) * else: * itemp = self.get_item_pointer(indices) # <<<<<<<<<<<<<< * return self.convert_item_to_object(itemp) * */ /*else*/ { __pyx_t_5 = ((struct __pyx_vtabstruct_memoryview *)__pyx_v_self->__pyx_vtab)->get_item_pointer(__pyx_v_self, __pyx_v_indices); if (unlikely(__pyx_t_5 == ((char *)NULL))) __PYX_ERR(1, 417, __pyx_L1_error) __pyx_v_itemp = __pyx_t_5; /* "View.MemoryView":418 * 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_2 = ((struct __pyx_vtabstruct_memoryview *)__pyx_v_self->__pyx_vtab)->convert_item_to_object(__pyx_v_self, __pyx_v_itemp); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 418, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __pyx_r = __pyx_t_2; __pyx_t_2 = 0; goto __pyx_L0; } /* "View.MemoryView":407 * * * def __getitem__(memoryview self, object index): # <<<<<<<<<<<<<< * if index is Ellipsis: * return self */ /* function exit code */ __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_2); __Pyx_XDECREF(__pyx_t_3); __Pyx_XDECREF(__pyx_t_4); __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":420 * 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) { CYTHON_UNUSED PyObject *const *__pyx_kwvalues; int __pyx_r; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__setitem__ (wrapper)", 0); __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs); __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 PyObject *__pyx_t_1 = NULL; PyObject *__pyx_t_2 = NULL; PyObject *__pyx_t_3 = NULL; int __pyx_t_4; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("__setitem__", 0); __Pyx_INCREF(__pyx_v_index); /* "View.MemoryView":421 * * def __setitem__(memoryview self, object index, object value): * if self.view.readonly: # <<<<<<<<<<<<<< * raise TypeError, "Cannot assign to read-only memoryview" * */ if (unlikely(__pyx_v_self->view.readonly)) { /* "View.MemoryView":422 * 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_Raise(__pyx_builtin_TypeError, __pyx_kp_s_Cannot_assign_to_read_only_memor, 0, 0); __PYX_ERR(1, 422, __pyx_L1_error) /* "View.MemoryView":421 * * def __setitem__(memoryview self, object index, object value): * if self.view.readonly: # <<<<<<<<<<<<<< * raise TypeError, "Cannot assign to read-only memoryview" * */ } /* "View.MemoryView":424 * raise TypeError, "Cannot assign to read-only memoryview" * * have_slices, index = _unellipsify(index, self.view.ndim) # <<<<<<<<<<<<<< * * if have_slices: */ __pyx_t_1 = _unellipsify(__pyx_v_index, __pyx_v_self->view.ndim); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 424, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); if (likely(__pyx_t_1 != Py_None)) { 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(1, 424, __pyx_L1_error) } #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS __pyx_t_2 = PyTuple_GET_ITEM(sequence, 0); __pyx_t_3 = PyTuple_GET_ITEM(sequence, 1); __Pyx_INCREF(__pyx_t_2); __Pyx_INCREF(__pyx_t_3); #else __pyx_t_2 = PySequence_ITEM(sequence, 0); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 424, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __pyx_t_3 = PySequence_ITEM(sequence, 1); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 424, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); #endif __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; } else { __Pyx_RaiseNoneNotIterableError(); __PYX_ERR(1, 424, __pyx_L1_error) } __pyx_v_have_slices = __pyx_t_2; __pyx_t_2 = 0; __Pyx_DECREF_SET(__pyx_v_index, __pyx_t_3); __pyx_t_3 = 0; /* "View.MemoryView":426 * have_slices, index = _unellipsify(index, self.view.ndim) * * if have_slices: # <<<<<<<<<<<<<< * obj = self.is_slice(value) * if obj: */ __pyx_t_4 = __Pyx_PyObject_IsTrue(__pyx_v_have_slices); if (unlikely((__pyx_t_4 < 0))) __PYX_ERR(1, 426, __pyx_L1_error) if (__pyx_t_4) { /* "View.MemoryView":427 * * if have_slices: * obj = self.is_slice(value) # <<<<<<<<<<<<<< * if obj: * self.setitem_slice_assignment(self[index], obj) */ __pyx_t_1 = ((struct __pyx_vtabstruct_memoryview *)__pyx_v_self->__pyx_vtab)->is_slice(__pyx_v_self, __pyx_v_value); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 427, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_v_obj = __pyx_t_1; __pyx_t_1 = 0; /* "View.MemoryView":428 * if have_slices: * obj = self.is_slice(value) * if obj: # <<<<<<<<<<<<<< * self.setitem_slice_assignment(self[index], obj) * else: */ __pyx_t_4 = __Pyx_PyObject_IsTrue(__pyx_v_obj); if (unlikely((__pyx_t_4 < 0))) __PYX_ERR(1, 428, __pyx_L1_error) if (__pyx_t_4) { /* "View.MemoryView":429 * 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_1 = __Pyx_PyObject_GetItem(((PyObject *)__pyx_v_self), __pyx_v_index); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 429, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_t_3 = ((struct __pyx_vtabstruct_memoryview *)__pyx_v_self->__pyx_vtab)->setitem_slice_assignment(__pyx_v_self, __pyx_t_1, __pyx_v_obj); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 429, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; /* "View.MemoryView":428 * if have_slices: * obj = self.is_slice(value) * if obj: # <<<<<<<<<<<<<< * self.setitem_slice_assignment(self[index], obj) * else: */ goto __pyx_L5; } /* "View.MemoryView":431 * 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_3 = __Pyx_PyObject_GetItem(((PyObject *)__pyx_v_self), __pyx_v_index); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 431, __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, 431, __pyx_L1_error) __pyx_t_1 = ((struct __pyx_vtabstruct_memoryview *)__pyx_v_self->__pyx_vtab)->setitem_slice_assign_scalar(__pyx_v_self, ((struct __pyx_memoryview_obj *)__pyx_t_3), __pyx_v_value); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 431, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; } __pyx_L5:; /* "View.MemoryView":426 * have_slices, index = _unellipsify(index, self.view.ndim) * * if have_slices: # <<<<<<<<<<<<<< * obj = self.is_slice(value) * if obj: */ goto __pyx_L4; } /* "View.MemoryView":433 * self.setitem_slice_assign_scalar(self[index], value) * else: * self.setitem_indexed(index, value) # <<<<<<<<<<<<<< * * cdef is_slice(self, obj): */ /*else*/ { __pyx_t_1 = ((struct __pyx_vtabstruct_memoryview *)__pyx_v_self->__pyx_vtab)->setitem_indexed(__pyx_v_self, __pyx_v_index, __pyx_v_value); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 433, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; } __pyx_L4:; /* "View.MemoryView":420 * 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_1); __Pyx_XDECREF(__pyx_t_2); __Pyx_XDECREF(__pyx_t_3); __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":435 * 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":436 * * 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); if (__pyx_t_2) { /* "View.MemoryView":437 * 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":438 * 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, 438, __pyx_L4_error) __Pyx_GOTREF(__pyx_t_6); /* "View.MemoryView":439 * 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, 439, __pyx_L4_error) __Pyx_GOTREF(__pyx_t_7); /* "View.MemoryView":438 * 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, 438, __pyx_L4_error) __Pyx_GOTREF(__pyx_t_8); __Pyx_INCREF(__pyx_v_obj); __Pyx_GIVEREF(__pyx_v_obj); if (__Pyx_PyTuple_SET_ITEM(__pyx_t_8, 0, __pyx_v_obj)) __PYX_ERR(1, 438, __pyx_L4_error); __Pyx_GIVEREF(__pyx_t_6); if (__Pyx_PyTuple_SET_ITEM(__pyx_t_8, 1, __pyx_t_6)) __PYX_ERR(1, 438, __pyx_L4_error); __Pyx_GIVEREF(__pyx_t_7); if (__Pyx_PyTuple_SET_ITEM(__pyx_t_8, 2, __pyx_t_7)) __PYX_ERR(1, 438, __pyx_L4_error); __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, 438, __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":437 * 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":440 * 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, 440, __pyx_L6_except_error) __Pyx_XGOTREF(__pyx_t_7); __Pyx_XGOTREF(__pyx_t_8); __Pyx_XGOTREF(__pyx_t_6); /* "View.MemoryView":441 * 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; /* "View.MemoryView":437 * 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_L6_except_error:; __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":436 * * cdef is_slice(self, obj): * if not isinstance(obj, memoryview): # <<<<<<<<<<<<<< * try: * obj = memoryview(obj, self.flags & ~PyBUF_WRITABLE | PyBUF_ANY_CONTIGUOUS, */ } /* "View.MemoryView":443 * 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":435 * 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":445 * 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; __Pyx_memviewslice __pyx_v_msrc; __Pyx_memviewslice __pyx_v_mdst; PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations __Pyx_memviewslice *__pyx_t_1; PyObject *__pyx_t_2 = NULL; int __pyx_t_3; int __pyx_t_4; int __pyx_t_5; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("setitem_slice_assignment", 1); /* "View.MemoryView":448 * cdef __Pyx_memviewslice dst_slice * cdef __Pyx_memviewslice src_slice * cdef __Pyx_memviewslice msrc = get_slice_from_memview(src, &src_slice)[0] # <<<<<<<<<<<<<< * cdef __Pyx_memviewslice mdst = get_slice_from_memview(dst, &dst_slice)[0] * */ if (!(likely(((__pyx_v_src) == Py_None) || likely(__Pyx_TypeTest(__pyx_v_src, __pyx_memoryview_type))))) __PYX_ERR(1, 448, __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, 448, __pyx_L1_error) __pyx_v_msrc = (__pyx_t_1[0]); /* "View.MemoryView":449 * cdef __Pyx_memviewslice src_slice * cdef __Pyx_memviewslice msrc = get_slice_from_memview(src, &src_slice)[0] * cdef __Pyx_memviewslice mdst = get_slice_from_memview(dst, &dst_slice)[0] # <<<<<<<<<<<<<< * * memoryview_copy_contents(msrc, mdst, 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, 449, __pyx_L1_error) __pyx_t_1 = __pyx_memoryview_get_slice_from_memoryview(((struct __pyx_memoryview_obj *)__pyx_v_dst), (&__pyx_v_dst_slice)); if (unlikely(__pyx_t_1 == ((__Pyx_memviewslice *)NULL))) __PYX_ERR(1, 449, __pyx_L1_error) __pyx_v_mdst = (__pyx_t_1[0]); /* "View.MemoryView":451 * cdef __Pyx_memviewslice mdst = get_slice_from_memview(dst, &dst_slice)[0] * * memoryview_copy_contents(msrc, mdst, src.ndim, dst.ndim, self.dtype_is_object) # <<<<<<<<<<<<<< * * cdef setitem_slice_assign_scalar(self, memoryview dst, value): */ __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_v_src, __pyx_n_s_ndim); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 451, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __pyx_t_3 = __Pyx_PyInt_As_int(__pyx_t_2); if (unlikely((__pyx_t_3 == (int)-1) && PyErr_Occurred())) __PYX_ERR(1, 451, __pyx_L1_error) __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_v_dst, __pyx_n_s_ndim); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 451, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __pyx_t_4 = __Pyx_PyInt_As_int(__pyx_t_2); if (unlikely((__pyx_t_4 == (int)-1) && PyErr_Occurred())) __PYX_ERR(1, 451, __pyx_L1_error) __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; __pyx_t_5 = __pyx_memoryview_copy_contents(__pyx_v_msrc, __pyx_v_mdst, __pyx_t_3, __pyx_t_4, __pyx_v_self->dtype_is_object); if (unlikely(__pyx_t_5 == ((int)-1))) __PYX_ERR(1, 451, __pyx_L1_error) /* "View.MemoryView":445 * 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_2); __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":453 * memoryview_copy_contents(msrc, mdst, 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", 1); /* "View.MemoryView":455 * 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":460 * 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, 460, __pyx_L1_error) __pyx_v_dst_slice = __pyx_t_1; /* "View.MemoryView":462 * 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))); if (__pyx_t_2) { /* "View.MemoryView":463 * * 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":464 * 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); if (unlikely(__pyx_t_2)) { /* "View.MemoryView":465 * tmp = PyMem_Malloc(self.view.itemsize) * if tmp == NULL: * raise MemoryError # <<<<<<<<<<<<<< * item = tmp * else: */ PyErr_NoMemory(); __PYX_ERR(1, 465, __pyx_L1_error) /* "View.MemoryView":464 * if self.view.itemsize > sizeof(array): * tmp = PyMem_Malloc(self.view.itemsize) * if tmp == NULL: # <<<<<<<<<<<<<< * raise MemoryError * item = tmp */ } /* "View.MemoryView":466 * if tmp == NULL: * raise MemoryError * item = tmp # <<<<<<<<<<<<<< * else: * item = array */ __pyx_v_item = __pyx_v_tmp; /* "View.MemoryView":462 * 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":468 * item = tmp * else: * item = array # <<<<<<<<<<<<<< * * try: */ /*else*/ { __pyx_v_item = ((void *)__pyx_v_array); } __pyx_L3:; /* "View.MemoryView":470 * item = array * * try: # <<<<<<<<<<<<<< * if self.dtype_is_object: * ( item)[0] = value */ /*try:*/ { /* "View.MemoryView":471 * * try: * if self.dtype_is_object: # <<<<<<<<<<<<<< * ( item)[0] = value * else: */ if (__pyx_v_self->dtype_is_object) { /* "View.MemoryView":472 * 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":471 * * try: * if self.dtype_is_object: # <<<<<<<<<<<<<< * ( item)[0] = value * else: */ goto __pyx_L8; } /* "View.MemoryView":474 * ( 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, 474, __pyx_L6_error) __Pyx_GOTREF(__pyx_t_3); __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; } __pyx_L8:; /* "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, */ __pyx_t_2 = (__pyx_v_self->view.suboffsets != NULL); if (__pyx_t_2) { /* "View.MemoryView":479 * * 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_4 = assert_direct_dimensions(__pyx_v_self->view.suboffsets, __pyx_v_self->view.ndim); if (unlikely(__pyx_t_4 == ((int)-1))) __PYX_ERR(1, 479, __pyx_L6_error) /* "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, */ } /* "View.MemoryView":480 * 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":483 * 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":453 * memoryview_copy_contents(msrc, mdst, 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":485 * 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", 1); /* "View.MemoryView":486 * * 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, 486, __pyx_L1_error) __pyx_v_itemp = __pyx_t_1; /* "View.MemoryView":487 * 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, 487, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; /* "View.MemoryView":485 * 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":489 * 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; 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("convert_item_to_object", 1); /* "View.MemoryView":492 * """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_ImportDottedModule(__pyx_n_s_struct, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 492, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_v_struct = __pyx_t_1; __pyx_t_1 = 0; /* "View.MemoryView":495 * 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, 495, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_v_bytesitem = ((PyObject*)__pyx_t_1); __pyx_t_1 = 0; /* "View.MemoryView":496 * * 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":497 * 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, 497, __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, 497, __pyx_L3_error) __Pyx_GOTREF(__pyx_t_6); __pyx_t_7 = NULL; __pyx_t_8 = 0; #if CYTHON_UNPACK_METHODS if (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; } } #endif { PyObject *__pyx_callargs[3] = {__pyx_t_7, __pyx_t_6, __pyx_v_bytesitem}; __pyx_t_1 = __Pyx_PyObject_FastCall(__pyx_t_5, __pyx_callargs+1-__pyx_t_8, 2+__pyx_t_8); __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 497, __pyx_L3_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; } __pyx_v_result = __pyx_t_1; __pyx_t_1 = 0; /* "View.MemoryView":496 * * bytesitem = itemp[:self.view.itemsize] * try: # <<<<<<<<<<<<<< * result = struct.unpack(self.view.format, bytesitem) * except struct.error: */ } /* "View.MemoryView":501 * raise ValueError, "Unable to convert item to object" * else: * if len(self.view.format) == 1: # <<<<<<<<<<<<<< * return result[0] * return result */ /*else:*/ { __pyx_t_9 = __Pyx_ssize_strlen(__pyx_v_self->view.format); if (unlikely(__pyx_t_9 == ((Py_ssize_t)-1))) __PYX_ERR(1, 501, __pyx_L5_except_error) __pyx_t_10 = (__pyx_t_9 == 1); if (__pyx_t_10) { /* "View.MemoryView":502 * 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, 502, __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":501 * raise ValueError, "Unable to convert item to object" * else: * if len(self.view.format) == 1: # <<<<<<<<<<<<<< * return result[0] * return result */ } /* "View.MemoryView":503 * 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; /* "View.MemoryView":498 * 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_6); __pyx_t_7 = __Pyx_PyObject_GetAttrStr(__pyx_v_struct, __pyx_n_s_error); if (unlikely(!__pyx_t_7)) __PYX_ERR(1, 498, __pyx_L5_except_error) __Pyx_GOTREF(__pyx_t_7); __pyx_t_8 = __Pyx_PyErr_GivenExceptionMatches(__pyx_t_1, __pyx_t_7); __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; __Pyx_ErrRestore(__pyx_t_1, __pyx_t_5, __pyx_t_6); __pyx_t_1 = 0; __pyx_t_5 = 0; __pyx_t_6 = 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_6, &__pyx_t_5, &__pyx_t_1) < 0) __PYX_ERR(1, 498, __pyx_L5_except_error) __Pyx_XGOTREF(__pyx_t_6); __Pyx_XGOTREF(__pyx_t_5); __Pyx_XGOTREF(__pyx_t_1); /* "View.MemoryView":499 * 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_Raise(__pyx_builtin_ValueError, __pyx_kp_s_Unable_to_convert_item_to_object, 0, 0); __PYX_ERR(1, 499, __pyx_L5_except_error) } goto __pyx_L5_except_error; /* "View.MemoryView":496 * * bytesitem = itemp[:self.view.itemsize] * try: # <<<<<<<<<<<<<< * result = struct.unpack(self.view.format, bytesitem) * except struct.error: */ __pyx_L5_except_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":489 * 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_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":505 * 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; PyObject *__pyx_t_3 = NULL; PyObject *__pyx_t_4 = NULL; PyObject *__pyx_t_5 = NULL; int __pyx_t_6; Py_ssize_t __pyx_t_7; PyObject *__pyx_t_8 = NULL; char *__pyx_t_9; char *__pyx_t_10; char *__pyx_t_11; char *__pyx_t_12; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("assign_item_from_object", 1); /* "View.MemoryView":508 * """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_ImportDottedModule(__pyx_n_s_struct, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 508, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_v_struct = __pyx_t_1; __pyx_t_1 = 0; /* "View.MemoryView":513 * 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); if (__pyx_t_2) { /* "View.MemoryView":514 * * 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, 514, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_t_3 = __Pyx_PyBytes_FromString(__pyx_v_self->view.format); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 514, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __pyx_t_4 = PyTuple_New(1); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 514, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __Pyx_GIVEREF(__pyx_t_3); if (__Pyx_PyTuple_SET_ITEM(__pyx_t_4, 0, __pyx_t_3)) __PYX_ERR(1, 514, __pyx_L1_error); __pyx_t_3 = 0; __pyx_t_3 = __Pyx_PySequence_Tuple(__pyx_v_value); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 514, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __pyx_t_5 = PyNumber_Add(__pyx_t_4, __pyx_t_3); if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 514, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_5); __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; __pyx_t_3 = __Pyx_PyObject_Call(__pyx_t_1, __pyx_t_5, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 514, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; if (!(likely(PyBytes_CheckExact(__pyx_t_3))||((__pyx_t_3) == Py_None) || __Pyx_RaiseUnexpectedTypeError("bytes", __pyx_t_3))) __PYX_ERR(1, 514, __pyx_L1_error) __pyx_v_bytesvalue = ((PyObject*)__pyx_t_3); __pyx_t_3 = 0; /* "View.MemoryView":513 * cdef Py_ssize_t i * * if isinstance(value, tuple): # <<<<<<<<<<<<<< * bytesvalue = struct.pack(self.view.format, *value) * else: */ goto __pyx_L3; } /* "View.MemoryView":516 * bytesvalue = struct.pack(self.view.format, *value) * else: * bytesvalue = struct.pack(self.view.format, value) # <<<<<<<<<<<<<< * * for i, c in enumerate(bytesvalue): */ /*else*/ { __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_v_struct, __pyx_n_s_pack); if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 516, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_5); __pyx_t_1 = __Pyx_PyBytes_FromString(__pyx_v_self->view.format); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 516, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_t_4 = NULL; __pyx_t_6 = 0; #if CYTHON_UNPACK_METHODS if (likely(PyMethod_Check(__pyx_t_5))) { __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_5); if (likely(__pyx_t_4)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_5); __Pyx_INCREF(__pyx_t_4); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_5, function); __pyx_t_6 = 1; } } #endif { PyObject *__pyx_callargs[3] = {__pyx_t_4, __pyx_t_1, __pyx_v_value}; __pyx_t_3 = __Pyx_PyObject_FastCall(__pyx_t_5, __pyx_callargs+1-__pyx_t_6, 2+__pyx_t_6); __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 516, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; } if (!(likely(PyBytes_CheckExact(__pyx_t_3))||((__pyx_t_3) == Py_None) || __Pyx_RaiseUnexpectedTypeError("bytes", __pyx_t_3))) __PYX_ERR(1, 516, __pyx_L1_error) __pyx_v_bytesvalue = ((PyObject*)__pyx_t_3); __pyx_t_3 = 0; } __pyx_L3:; /* "View.MemoryView":518 * bytesvalue = struct.pack(self.view.format, value) * * for i, c in enumerate(bytesvalue): # <<<<<<<<<<<<<< * itemp[i] = c * */ __pyx_t_7 = 0; if (unlikely(__pyx_v_bytesvalue == Py_None)) { PyErr_SetString(PyExc_TypeError, "'NoneType' is not iterable"); __PYX_ERR(1, 518, __pyx_L1_error) } __Pyx_INCREF(__pyx_v_bytesvalue); __pyx_t_8 = __pyx_v_bytesvalue; __pyx_t_10 = PyBytes_AS_STRING(__pyx_t_8); __pyx_t_11 = (__pyx_t_10 + PyBytes_GET_SIZE(__pyx_t_8)); for (__pyx_t_12 = __pyx_t_10; __pyx_t_12 < __pyx_t_11; __pyx_t_12++) { __pyx_t_9 = __pyx_t_12; __pyx_v_c = (__pyx_t_9[0]); /* "View.MemoryView":519 * * for i, c in enumerate(bytesvalue): * itemp[i] = c # <<<<<<<<<<<<<< * * @cname('getbuffer') */ __pyx_v_i = __pyx_t_7; /* "View.MemoryView":518 * bytesvalue = struct.pack(self.view.format, value) * * for i, c in enumerate(bytesvalue): # <<<<<<<<<<<<<< * itemp[i] = c * */ __pyx_t_7 = (__pyx_t_7 + 1); /* "View.MemoryView":519 * * for i, c in enumerate(bytesvalue): * itemp[i] = c # <<<<<<<<<<<<<< * * @cname('getbuffer') */ (__pyx_v_itemp[__pyx_v_i]) = __pyx_v_c; } __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; /* "View.MemoryView":505 * 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_3); __Pyx_XDECREF(__pyx_t_4); __Pyx_XDECREF(__pyx_t_5); __Pyx_XDECREF(__pyx_t_8); __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":521 * itemp[i] = c * * @cname('getbuffer') # <<<<<<<<<<<<<< * def __getbuffer__(self, Py_buffer *info, int flags): * if flags & PyBUF_WRITABLE and self.view.readonly: */ /* Python wrapper */ CYTHON_UNUSED static int __pyx_memoryview_getbuffer(PyObject *__pyx_v_self, Py_buffer *__pyx_v_info, int __pyx_v_flags); /*proto*/ CYTHON_UNUSED static int __pyx_memoryview_getbuffer(PyObject *__pyx_v_self, Py_buffer *__pyx_v_info, int __pyx_v_flags) { CYTHON_UNUSED PyObject *const *__pyx_kwvalues; int __pyx_r; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__getbuffer__ (wrapper)", 0); __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs); __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; Py_ssize_t *__pyx_t_3; char *__pyx_t_4; void *__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 (unlikely(__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":523 * @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_1 = __pyx_v_self->view.readonly; __pyx_L4_bool_binop_done:; if (unlikely(__pyx_t_1)) { /* "View.MemoryView":524 * 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_Raise(__pyx_builtin_ValueError, __pyx_kp_s_Cannot_create_writable_memory_vi, 0, 0); __PYX_ERR(1, 524, __pyx_L1_error) /* "View.MemoryView":523 * @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":526 * 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":527 * * if flags & PyBUF_ND: * info.shape = self.view.shape # <<<<<<<<<<<<<< * else: * info.shape = NULL */ __pyx_t_3 = __pyx_v_self->view.shape; __pyx_v_info->shape = __pyx_t_3; /* "View.MemoryView":526 * 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":529 * info.shape = self.view.shape * else: * info.shape = NULL # <<<<<<<<<<<<<< * * if flags & PyBUF_STRIDES: */ /*else*/ { __pyx_v_info->shape = NULL; } __pyx_L6:; /* "View.MemoryView":531 * 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":532 * * if flags & PyBUF_STRIDES: * info.strides = self.view.strides # <<<<<<<<<<<<<< * else: * info.strides = NULL */ __pyx_t_3 = __pyx_v_self->view.strides; __pyx_v_info->strides = __pyx_t_3; /* "View.MemoryView":531 * info.shape = NULL * * if flags & PyBUF_STRIDES: # <<<<<<<<<<<<<< * info.strides = self.view.strides * else: */ goto __pyx_L7; } /* "View.MemoryView":534 * info.strides = self.view.strides * else: * info.strides = NULL # <<<<<<<<<<<<<< * * if flags & PyBUF_INDIRECT: */ /*else*/ { __pyx_v_info->strides = NULL; } __pyx_L7:; /* "View.MemoryView":536 * 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":537 * * if flags & PyBUF_INDIRECT: * info.suboffsets = self.view.suboffsets # <<<<<<<<<<<<<< * else: * info.suboffsets = NULL */ __pyx_t_3 = __pyx_v_self->view.suboffsets; __pyx_v_info->suboffsets = __pyx_t_3; /* "View.MemoryView":536 * info.strides = NULL * * if flags & PyBUF_INDIRECT: # <<<<<<<<<<<<<< * info.suboffsets = self.view.suboffsets * else: */ goto __pyx_L8; } /* "View.MemoryView":539 * info.suboffsets = self.view.suboffsets * else: * info.suboffsets = NULL # <<<<<<<<<<<<<< * * if flags & PyBUF_FORMAT: */ /*else*/ { __pyx_v_info->suboffsets = NULL; } __pyx_L8:; /* "View.MemoryView":541 * 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":542 * * if flags & PyBUF_FORMAT: * info.format = self.view.format # <<<<<<<<<<<<<< * else: * info.format = NULL */ __pyx_t_4 = __pyx_v_self->view.format; __pyx_v_info->format = __pyx_t_4; /* "View.MemoryView":541 * info.suboffsets = NULL * * if flags & PyBUF_FORMAT: # <<<<<<<<<<<<<< * info.format = self.view.format * else: */ goto __pyx_L9; } /* "View.MemoryView":544 * info.format = self.view.format * else: * info.format = NULL # <<<<<<<<<<<<<< * * info.buf = self.view.buf */ /*else*/ { __pyx_v_info->format = NULL; } __pyx_L9:; /* "View.MemoryView":546 * info.format = NULL * * info.buf = self.view.buf # <<<<<<<<<<<<<< * info.ndim = self.view.ndim * info.itemsize = self.view.itemsize */ __pyx_t_5 = __pyx_v_self->view.buf; __pyx_v_info->buf = __pyx_t_5; /* "View.MemoryView":547 * * info.buf = self.view.buf * info.ndim = self.view.ndim # <<<<<<<<<<<<<< * info.itemsize = self.view.itemsize * info.len = self.view.len */ __pyx_t_6 = __pyx_v_self->view.ndim; __pyx_v_info->ndim = __pyx_t_6; /* "View.MemoryView":548 * 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_7 = __pyx_v_self->view.itemsize; __pyx_v_info->itemsize = __pyx_t_7; /* "View.MemoryView":549 * 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_7 = __pyx_v_self->view.len; __pyx_v_info->len = __pyx_t_7; /* "View.MemoryView":550 * 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":551 * info.len = self.view.len * info.readonly = self.view.readonly * info.obj = self # <<<<<<<<<<<<<< * * */ __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":521 * itemp[i] = c * * @cname('getbuffer') # <<<<<<<<<<<<<< * def __getbuffer__(self, Py_buffer *info, int flags): * if flags & PyBUF_WRITABLE and self.view.readonly: */ /* function exit code */ __pyx_r = 0; goto __pyx_L0; __pyx_L1_error:; __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":554 * * * @property # <<<<<<<<<<<<<< * def T(self): * cdef _memoryviewslice result = memoryview_copy(self) */ /* 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) { CYTHON_UNUSED PyObject *const *__pyx_kwvalues; PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__get__ (wrapper)", 0); __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs); __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__", 1); /* "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)-1))) __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":554 * * * @property # <<<<<<<<<<<<<< * def T(self): * cdef _memoryviewslice result = memoryview_copy(self) */ /* 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":560 * return result * * @property # <<<<<<<<<<<<<< * def base(self): * return self._get_base() */ /* 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) { CYTHON_UNUSED PyObject *const *__pyx_kwvalues; PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__get__ (wrapper)", 0); __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs); __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 PyObject *__pyx_t_1 = NULL; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("__get__", 1); /* "View.MemoryView":562 * @property * def base(self): * return self._get_base() # <<<<<<<<<<<<<< * * cdef _get_base(self): */ __Pyx_XDECREF(__pyx_r); __pyx_t_1 = ((struct __pyx_vtabstruct_memoryview *)__pyx_v_self->__pyx_vtab)->_get_base(__pyx_v_self); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 562, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_r = __pyx_t_1; __pyx_t_1 = 0; goto __pyx_L0; /* "View.MemoryView":560 * return result * * @property # <<<<<<<<<<<<<< * def base(self): * return self._get_base() */ /* function exit code */ __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_1); __Pyx_AddTraceback("View.MemoryView.memoryview.base.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __pyx_L0:; __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "View.MemoryView":564 * return self._get_base() * * cdef _get_base(self): # <<<<<<<<<<<<<< * return self.obj * */ static PyObject *__pyx_memoryview__get_base(struct __pyx_memoryview_obj *__pyx_v_self) { PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("_get_base", 1); /* "View.MemoryView":565 * * cdef _get_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":564 * return self._get_base() * * cdef _get_base(self): # <<<<<<<<<<<<<< * return self.obj * */ /* function exit code */ __pyx_L0:; __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "View.MemoryView":567 * return self.obj * * @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) { CYTHON_UNUSED PyObject *const *__pyx_kwvalues; PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__get__ (wrapper)", 0); __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs); __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_7genexpr__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__", 1); /* "View.MemoryView":569 * @property * def shape(self): * return tuple([length for length in self.view.shape[:self.view.ndim]]) # <<<<<<<<<<<<<< * * @property */ __Pyx_XDECREF(__pyx_r); { /* enter inner scope */ __pyx_t_1 = PyList_New(0); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 569, __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_7genexpr__pyx_v_length = (__pyx_t_2[0]); __pyx_t_5 = PyInt_FromSsize_t(__pyx_7genexpr__pyx_v_length); if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 569, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_5); if (unlikely(__Pyx_ListComp_Append(__pyx_t_1, (PyObject*)__pyx_t_5))) __PYX_ERR(1, 569, __pyx_L1_error) __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; } } /* exit inner scope */ __pyx_t_5 = PyList_AsTuple(((PyObject*)__pyx_t_1)); if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 569, __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":567 * return self.obj * * @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":571 * return tuple([length for length in self.view.shape[:self.view.ndim]]) * * @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) { CYTHON_UNUSED PyObject *const *__pyx_kwvalues; PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__get__ (wrapper)", 0); __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs); __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_8genexpr1__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__", 1); /* "View.MemoryView":573 * @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); if (unlikely(__pyx_t_1)) { /* "View.MemoryView":575 * 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_Raise(__pyx_builtin_ValueError, __pyx_kp_s_Buffer_view_does_not_expose_stri, 0, 0); __PYX_ERR(1, 575, __pyx_L1_error) /* "View.MemoryView":573 * @property * def strides(self): * if self.view.strides == NULL: # <<<<<<<<<<<<<< * * raise ValueError, "Buffer view does not expose strides" */ } /* "View.MemoryView":577 * 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); { /* enter inner scope */ __pyx_t_2 = PyList_New(0); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 577, __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_8genexpr1__pyx_v_stride = (__pyx_t_3[0]); __pyx_t_6 = PyInt_FromSsize_t(__pyx_8genexpr1__pyx_v_stride); if (unlikely(!__pyx_t_6)) __PYX_ERR(1, 577, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); if (unlikely(__Pyx_ListComp_Append(__pyx_t_2, (PyObject*)__pyx_t_6))) __PYX_ERR(1, 577, __pyx_L1_error) __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; } } /* exit inner scope */ __pyx_t_6 = PyList_AsTuple(((PyObject*)__pyx_t_2)); if (unlikely(!__pyx_t_6)) __PYX_ERR(1, 577, __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":571 * return tuple([length for length in self.view.shape[:self.view.ndim]]) * * @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":579 * return tuple([stride for stride in self.view.strides[:self.view.ndim]]) * * @property # <<<<<<<<<<<<<< * def suboffsets(self): * if self.view.suboffsets == NULL: */ /* 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) { CYTHON_UNUSED PyObject *const *__pyx_kwvalues; PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__get__ (wrapper)", 0); __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs); __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_8genexpr2__pyx_v_suboffset; 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__", 1); /* "View.MemoryView":581 * @property * def suboffsets(self): * if self.view.suboffsets == NULL: # <<<<<<<<<<<<<< * return (-1,) * self.view.ndim * */ __pyx_t_1 = (__pyx_v_self->view.suboffsets == NULL); if (__pyx_t_1) { /* "View.MemoryView":582 * 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_PySequence_Multiply(__pyx_tuple__4, __pyx_v_self->view.ndim); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 582, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __pyx_r = __pyx_t_2; __pyx_t_2 = 0; goto __pyx_L0; /* "View.MemoryView":581 * @property * def suboffsets(self): * if self.view.suboffsets == NULL: # <<<<<<<<<<<<<< * return (-1,) * self.view.ndim * */ } /* "View.MemoryView":584 * return (-1,) * self.view.ndim * * return tuple([suboffset for suboffset in self.view.suboffsets[:self.view.ndim]]) # <<<<<<<<<<<<<< * * @property */ __Pyx_XDECREF(__pyx_r); { /* enter inner scope */ __pyx_t_2 = PyList_New(0); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 584, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __pyx_t_4 = (__pyx_v_self->view.suboffsets + __pyx_v_self->view.ndim); for (__pyx_t_5 = __pyx_v_self->view.suboffsets; __pyx_t_5 < __pyx_t_4; __pyx_t_5++) { __pyx_t_3 = __pyx_t_5; __pyx_8genexpr2__pyx_v_suboffset = (__pyx_t_3[0]); __pyx_t_6 = PyInt_FromSsize_t(__pyx_8genexpr2__pyx_v_suboffset); if (unlikely(!__pyx_t_6)) __PYX_ERR(1, 584, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); if (unlikely(__Pyx_ListComp_Append(__pyx_t_2, (PyObject*)__pyx_t_6))) __PYX_ERR(1, 584, __pyx_L1_error) __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; } } /* exit inner scope */ __pyx_t_6 = PyList_AsTuple(((PyObject*)__pyx_t_2)); if (unlikely(!__pyx_t_6)) __PYX_ERR(1, 584, __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":579 * return tuple([stride for stride in self.view.strides[:self.view.ndim]]) * * @property # <<<<<<<<<<<<<< * def suboffsets(self): * if self.view.suboffsets == NULL: */ /* function exit code */ __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_2); __Pyx_XDECREF(__pyx_t_6); __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":586 * return tuple([suboffset for suboffset in self.view.suboffsets[:self.view.ndim]]) * * @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) { CYTHON_UNUSED PyObject *const *__pyx_kwvalues; PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__get__ (wrapper)", 0); __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs); __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__", 1); /* "View.MemoryView":588 * @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, 588, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_r = __pyx_t_1; __pyx_t_1 = 0; goto __pyx_L0; /* "View.MemoryView":586 * return tuple([suboffset for suboffset in self.view.suboffsets[:self.view.ndim]]) * * @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":590 * return self.view.ndim * * @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) { CYTHON_UNUSED PyObject *const *__pyx_kwvalues; PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__get__ (wrapper)", 0); __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs); __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__", 1); /* "View.MemoryView":592 * @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, 592, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_r = __pyx_t_1; __pyx_t_1 = 0; goto __pyx_L0; /* "View.MemoryView":590 * return self.view.ndim * * @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":594 * return self.view.itemsize * * @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) { CYTHON_UNUSED PyObject *const *__pyx_kwvalues; PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__get__ (wrapper)", 0); __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs); __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__", 1); /* "View.MemoryView":596 * @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, 596, __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, 596, __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, 596, __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":594 * return self.view.itemsize * * @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":598 * return self.size * self.view.itemsize * * @property # <<<<<<<<<<<<<< * def size(self): * if self._size is None: */ /* 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) { CYTHON_UNUSED PyObject *const *__pyx_kwvalues; PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__get__ (wrapper)", 0); __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs); __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; 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__", 1); /* "View.MemoryView":600 * @property * def size(self): * if self._size is None: # <<<<<<<<<<<<<< * result = 1 * */ __pyx_t_1 = (__pyx_v_self->_size == Py_None); if (__pyx_t_1) { /* "View.MemoryView":601 * 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":603 * result = 1 * * for length in self.view.shape[:self.view.ndim]: # <<<<<<<<<<<<<< * result *= length * */ __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_t_5 = PyInt_FromSsize_t((__pyx_t_2[0])); if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 603, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_5); __Pyx_XDECREF_SET(__pyx_v_length, __pyx_t_5); __pyx_t_5 = 0; /* "View.MemoryView":604 * * for length in self.view.shape[:self.view.ndim]: * result *= length # <<<<<<<<<<<<<< * * self._size = result */ __pyx_t_5 = PyNumber_InPlaceMultiply(__pyx_v_result, __pyx_v_length); if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 604, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_5); __Pyx_DECREF_SET(__pyx_v_result, __pyx_t_5); __pyx_t_5 = 0; } /* "View.MemoryView":606 * 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":600 * @property * def size(self): * if self._size is None: # <<<<<<<<<<<<<< * result = 1 * */ } /* "View.MemoryView":608 * 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":598 * return self.size * self.view.itemsize * * @property # <<<<<<<<<<<<<< * def size(self): * if self._size is None: */ /* function exit code */ __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_5); __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":610 * 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) { CYTHON_UNUSED PyObject *const *__pyx_kwvalues; Py_ssize_t __pyx_r; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__len__ (wrapper)", 0); __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs); __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; int __pyx_t_1; /* "View.MemoryView":611 * * def __len__(self): * if self.view.ndim >= 1: # <<<<<<<<<<<<<< * return self.view.shape[0] * */ __pyx_t_1 = (__pyx_v_self->view.ndim >= 1); if (__pyx_t_1) { /* "View.MemoryView":612 * 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":611 * * def __len__(self): * if self.view.ndim >= 1: # <<<<<<<<<<<<<< * return self.view.shape[0] * */ } /* "View.MemoryView":614 * return self.view.shape[0] * * return 0 # <<<<<<<<<<<<<< * * def __repr__(self): */ __pyx_r = 0; goto __pyx_L0; /* "View.MemoryView":610 * return self._size * * def __len__(self): # <<<<<<<<<<<<<< * if self.view.ndim >= 1: * return self.view.shape[0] */ /* function exit code */ __pyx_L0:; return __pyx_r; } /* "View.MemoryView":616 * 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) { CYTHON_UNUSED PyObject *const *__pyx_kwvalues; PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__repr__ (wrapper)", 0); __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs); __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__", 1); /* "View.MemoryView":617 * * 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, 617, __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, 617, __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, 617, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; /* "View.MemoryView":618 * 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, 618, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); /* "View.MemoryView":617 * * def __repr__(self): * return "" % (self.base.__class__.__name__, # <<<<<<<<<<<<<< * id(self)) * */ __pyx_t_3 = PyTuple_New(2); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 617, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __Pyx_GIVEREF(__pyx_t_1); if (__Pyx_PyTuple_SET_ITEM(__pyx_t_3, 0, __pyx_t_1)) __PYX_ERR(1, 617, __pyx_L1_error); __Pyx_GIVEREF(__pyx_t_2); if (__Pyx_PyTuple_SET_ITEM(__pyx_t_3, 1, __pyx_t_2)) __PYX_ERR(1, 617, __pyx_L1_error); __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, 617, __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":616 * 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":620 * 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) { CYTHON_UNUSED PyObject *const *__pyx_kwvalues; PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__str__ (wrapper)", 0); __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs); __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__", 1); /* "View.MemoryView":621 * * 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, 621, __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, 621, __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, 621, __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, 621, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __Pyx_GIVEREF(__pyx_t_1); if (__Pyx_PyTuple_SET_ITEM(__pyx_t_2, 0, __pyx_t_1)) __PYX_ERR(1, 621, __pyx_L1_error); __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, 621, __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":620 * 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":624 * * * 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, #if CYTHON_METH_FASTCALL PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds #else PyObject *__pyx_args, PyObject *__pyx_kwds #endif ); /*proto*/ static PyObject *__pyx_memoryview_is_c_contig(PyObject *__pyx_v_self, #if CYTHON_METH_FASTCALL PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds #else PyObject *__pyx_args, PyObject *__pyx_kwds #endif ) { #if !CYTHON_METH_FASTCALL CYTHON_UNUSED Py_ssize_t __pyx_nargs; #endif CYTHON_UNUSED PyObject *const *__pyx_kwvalues; PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("is_c_contig (wrapper)", 0); #if !CYTHON_METH_FASTCALL #if CYTHON_ASSUME_SAFE_MACROS __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); #else __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; #endif #endif __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); if (unlikely(__pyx_nargs > 0)) { __Pyx_RaiseArgtupleInvalid("is_c_contig", 1, 0, 0, __pyx_nargs); return NULL;} if (unlikely(__pyx_kwds) && __Pyx_NumKwargs_FASTCALL(__pyx_kwds) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "is_c_contig", 0))) return NULL; __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", 1); /* "View.MemoryView":627 * 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, 627, __pyx_L1_error) __pyx_v_mslice = __pyx_t_1; /* "View.MemoryView":628 * 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, 628, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __pyx_r = __pyx_t_2; __pyx_t_2 = 0; goto __pyx_L0; /* "View.MemoryView":624 * * * 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":630 * 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, #if CYTHON_METH_FASTCALL PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds #else PyObject *__pyx_args, PyObject *__pyx_kwds #endif ); /*proto*/ static PyObject *__pyx_memoryview_is_f_contig(PyObject *__pyx_v_self, #if CYTHON_METH_FASTCALL PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds #else PyObject *__pyx_args, PyObject *__pyx_kwds #endif ) { #if !CYTHON_METH_FASTCALL CYTHON_UNUSED Py_ssize_t __pyx_nargs; #endif CYTHON_UNUSED PyObject *const *__pyx_kwvalues; PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("is_f_contig (wrapper)", 0); #if !CYTHON_METH_FASTCALL #if CYTHON_ASSUME_SAFE_MACROS __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); #else __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; #endif #endif __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); if (unlikely(__pyx_nargs > 0)) { __Pyx_RaiseArgtupleInvalid("is_f_contig", 1, 0, 0, __pyx_nargs); return NULL;} if (unlikely(__pyx_kwds) && __Pyx_NumKwargs_FASTCALL(__pyx_kwds) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "is_f_contig", 0))) return NULL; __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", 1); /* "View.MemoryView":633 * 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, 633, __pyx_L1_error) __pyx_v_mslice = __pyx_t_1; /* "View.MemoryView":634 * 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, 634, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __pyx_r = __pyx_t_2; __pyx_t_2 = 0; goto __pyx_L0; /* "View.MemoryView":630 * 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":636 * 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, #if CYTHON_METH_FASTCALL PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds #else PyObject *__pyx_args, PyObject *__pyx_kwds #endif ); /*proto*/ static PyObject *__pyx_memoryview_copy(PyObject *__pyx_v_self, #if CYTHON_METH_FASTCALL PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds #else PyObject *__pyx_args, PyObject *__pyx_kwds #endif ) { #if !CYTHON_METH_FASTCALL CYTHON_UNUSED Py_ssize_t __pyx_nargs; #endif CYTHON_UNUSED PyObject *const *__pyx_kwvalues; PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("copy (wrapper)", 0); #if !CYTHON_METH_FASTCALL #if CYTHON_ASSUME_SAFE_MACROS __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); #else __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; #endif #endif __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); if (unlikely(__pyx_nargs > 0)) { __Pyx_RaiseArgtupleInvalid("copy", 1, 0, 0, __pyx_nargs); return NULL;} if (unlikely(__pyx_kwds) && __Pyx_NumKwargs_FASTCALL(__pyx_kwds) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "copy", 0))) return NULL; __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", 1); /* "View.MemoryView":638 * 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":640 * 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":641 * * 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, 641, __pyx_L1_error) __pyx_v_mslice = __pyx_t_1; /* "View.MemoryView":646 * 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, 646, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __pyx_r = __pyx_t_2; __pyx_t_2 = 0; goto __pyx_L0; /* "View.MemoryView":636 * 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":648 * 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, #if CYTHON_METH_FASTCALL PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds #else PyObject *__pyx_args, PyObject *__pyx_kwds #endif ); /*proto*/ static PyObject *__pyx_memoryview_copy_fortran(PyObject *__pyx_v_self, #if CYTHON_METH_FASTCALL PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds #else PyObject *__pyx_args, PyObject *__pyx_kwds #endif ) { #if !CYTHON_METH_FASTCALL CYTHON_UNUSED Py_ssize_t __pyx_nargs; #endif CYTHON_UNUSED PyObject *const *__pyx_kwvalues; PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("copy_fortran (wrapper)", 0); #if !CYTHON_METH_FASTCALL #if CYTHON_ASSUME_SAFE_MACROS __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); #else __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; #endif #endif __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); if (unlikely(__pyx_nargs > 0)) { __Pyx_RaiseArgtupleInvalid("copy_fortran", 1, 0, 0, __pyx_nargs); return NULL;} if (unlikely(__pyx_kwds) && __Pyx_NumKwargs_FASTCALL(__pyx_kwds) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "copy_fortran", 0))) return NULL; __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", 1); /* "View.MemoryView":650 * 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":652 * 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":653 * * 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, 653, __pyx_L1_error) __pyx_v_dst = __pyx_t_1; /* "View.MemoryView":658 * 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, 658, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __pyx_r = __pyx_t_2; __pyx_t_2 = 0; goto __pyx_L0; /* "View.MemoryView":648 * 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, #if CYTHON_METH_FASTCALL PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds #else PyObject *__pyx_args, PyObject *__pyx_kwds #endif ); /*proto*/ static PyObject *__pyx_pw___pyx_memoryview_1__reduce_cython__(PyObject *__pyx_v_self, #if CYTHON_METH_FASTCALL PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds #else PyObject *__pyx_args, PyObject *__pyx_kwds #endif ) { #if !CYTHON_METH_FASTCALL CYTHON_UNUSED Py_ssize_t __pyx_nargs; #endif CYTHON_UNUSED PyObject *const *__pyx_kwvalues; PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__reduce_cython__ (wrapper)", 0); #if !CYTHON_METH_FASTCALL #if CYTHON_ASSUME_SAFE_MACROS __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); #else __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; #endif #endif __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); if (unlikely(__pyx_nargs > 0)) { __Pyx_RaiseArgtupleInvalid("__reduce_cython__", 1, 0, 0, __pyx_nargs); return NULL;} if (unlikely(__pyx_kwds) && __Pyx_NumKwargs_FASTCALL(__pyx_kwds) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "__reduce_cython__", 0))) return NULL; __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 int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("__reduce_cython__", 1); /* "(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_Raise(__pyx_builtin_TypeError, __pyx_kp_s_no_default___reduce___due_to_non, 0, 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_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, #if CYTHON_METH_FASTCALL PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds #else PyObject *__pyx_args, PyObject *__pyx_kwds #endif ); /*proto*/ static PyObject *__pyx_pw___pyx_memoryview_3__setstate_cython__(PyObject *__pyx_v_self, #if CYTHON_METH_FASTCALL PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds #else PyObject *__pyx_args, PyObject *__pyx_kwds #endif ) { CYTHON_UNUSED PyObject *__pyx_v___pyx_state = 0; #if !CYTHON_METH_FASTCALL CYTHON_UNUSED Py_ssize_t __pyx_nargs; #endif CYTHON_UNUSED PyObject *const *__pyx_kwvalues; PyObject* values[1] = {0}; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__setstate_cython__ (wrapper)", 0); #if !CYTHON_METH_FASTCALL #if CYTHON_ASSUME_SAFE_MACROS __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); #else __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; #endif #endif __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); { PyObject **__pyx_pyargnames[] = {&__pyx_n_s_pyx_state,0}; if (__pyx_kwds) { Py_ssize_t kw_args; switch (__pyx_nargs) { case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); CYTHON_FALLTHROUGH; case 0: break; default: goto __pyx_L5_argtuple_error; } kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); switch (__pyx_nargs) { case 0: if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_pyx_state)) != 0)) { (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); kw_args--; } else if (unlikely(PyErr_Occurred())) __PYX_ERR(1, 3, __pyx_L3_error) else goto __pyx_L5_argtuple_error; } if (unlikely(kw_args > 0)) { const Py_ssize_t kwd_pos_args = __pyx_nargs; if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "__setstate_cython__") < 0)) __PYX_ERR(1, 3, __pyx_L3_error) } } else if (unlikely(__pyx_nargs != 1)) { goto __pyx_L5_argtuple_error; } else { values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); } __pyx_v___pyx_state = values[0]; } goto __pyx_L6_skip; __pyx_L5_argtuple_error:; __Pyx_RaiseArgtupleInvalid("__setstate_cython__", 1, 1, 1, __pyx_nargs); __PYX_ERR(1, 3, __pyx_L3_error) __pyx_L6_skip:; goto __pyx_L4_argument_unpacking_done; __pyx_L3_error:; { Py_ssize_t __pyx_temp; for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); } } __Pyx_AddTraceback("View.MemoryView.memoryview.__setstate_cython__", __pyx_clineno, __pyx_lineno, __pyx_filename); __Pyx_RefNannyFinishContext(); return NULL; __pyx_L4_argument_unpacking_done:; __pyx_r = __pyx_pf___pyx_memoryview_2__setstate_cython__(((struct __pyx_memoryview_obj *)__pyx_v_self), __pyx_v___pyx_state); /* function exit code */ { Py_ssize_t __pyx_temp; for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); } } __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 int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("__setstate_cython__", 1); /* "(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_Raise(__pyx_builtin_TypeError, __pyx_kp_s_no_default___reduce___due_to_non, 0, 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_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":662 * * @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", 1); /* "View.MemoryView":663 * @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, 663, __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, 663, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __pyx_t_3 = PyTuple_New(3); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 663, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __Pyx_INCREF(__pyx_v_o); __Pyx_GIVEREF(__pyx_v_o); if (__Pyx_PyTuple_SET_ITEM(__pyx_t_3, 0, __pyx_v_o)) __PYX_ERR(1, 663, __pyx_L1_error); __Pyx_GIVEREF(__pyx_t_1); if (__Pyx_PyTuple_SET_ITEM(__pyx_t_3, 1, __pyx_t_1)) __PYX_ERR(1, 663, __pyx_L1_error); __Pyx_GIVEREF(__pyx_t_2); if (__Pyx_PyTuple_SET_ITEM(__pyx_t_3, 2, __pyx_t_2)) __PYX_ERR(1, 663, __pyx_L1_error); __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, 663, __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":664 * 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":665 * 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":662 * * @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":668 * * @cname('__pyx_memoryview_check') * cdef inline bint memoryview_check(object o) noexcept: # <<<<<<<<<<<<<< * return isinstance(o, memoryview) * */ static CYTHON_INLINE int __pyx_memoryview_check(PyObject *__pyx_v_o) { int __pyx_r; int __pyx_t_1; /* "View.MemoryView":669 * @cname('__pyx_memoryview_check') * cdef inline bint memoryview_check(object o) noexcept: * 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":668 * * @cname('__pyx_memoryview_check') * cdef inline bint memoryview_check(object o) noexcept: # <<<<<<<<<<<<<< * return isinstance(o, memoryview) * */ /* function exit code */ __pyx_L0:; return __pyx_r; } /* "View.MemoryView":671 * 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) { Py_ssize_t __pyx_v_idx; PyObject *__pyx_v_tup = NULL; PyObject *__pyx_v_result = NULL; int __pyx_v_have_slices; int __pyx_v_seen_ellipsis; PyObject *__pyx_v_item = NULL; Py_ssize_t __pyx_v_nslices; PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; int __pyx_t_2; PyObject *__pyx_t_3 = NULL; Py_ssize_t __pyx_t_4; Py_ssize_t __pyx_t_5; Py_UCS4 __pyx_t_6; PyObject *__pyx_t_7 = NULL; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("_unellipsify", 1); /* "View.MemoryView":677 * """ * cdef Py_ssize_t idx * tup = index if isinstance(index, tuple) else (index,) # <<<<<<<<<<<<<< * * result = [slice(None)] * ndim */ __pyx_t_2 = PyTuple_Check(__pyx_v_index); if (__pyx_t_2) { __Pyx_INCREF(((PyObject*)__pyx_v_index)); __pyx_t_1 = __pyx_v_index; } else { __pyx_t_3 = PyTuple_New(1); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 677, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __Pyx_INCREF(__pyx_v_index); __Pyx_GIVEREF(__pyx_v_index); if (__Pyx_PyTuple_SET_ITEM(__pyx_t_3, 0, __pyx_v_index)) __PYX_ERR(1, 677, __pyx_L1_error); __pyx_t_1 = __pyx_t_3; __pyx_t_3 = 0; } __pyx_v_tup = ((PyObject*)__pyx_t_1); __pyx_t_1 = 0; /* "View.MemoryView":679 * tup = index if isinstance(index, tuple) else (index,) * * result = [slice(None)] * ndim # <<<<<<<<<<<<<< * have_slices = False * seen_ellipsis = False */ __pyx_t_1 = PyList_New(1 * ((__pyx_v_ndim<0) ? 0:__pyx_v_ndim)); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 679, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); { Py_ssize_t __pyx_temp; for (__pyx_temp=0; __pyx_temp < __pyx_v_ndim; __pyx_temp++) { __Pyx_INCREF(__pyx_slice__5); __Pyx_GIVEREF(__pyx_slice__5); if (__Pyx_PyList_SET_ITEM(__pyx_t_1, __pyx_temp, __pyx_slice__5)) __PYX_ERR(1, 679, __pyx_L1_error); } } __pyx_v_result = ((PyObject*)__pyx_t_1); __pyx_t_1 = 0; /* "View.MemoryView":680 * * result = [slice(None)] * ndim * have_slices = False # <<<<<<<<<<<<<< * seen_ellipsis = False * idx = 0 */ __pyx_v_have_slices = 0; /* "View.MemoryView":681 * result = [slice(None)] * ndim * have_slices = False * seen_ellipsis = False # <<<<<<<<<<<<<< * idx = 0 * for item in tup: */ __pyx_v_seen_ellipsis = 0; /* "View.MemoryView":682 * have_slices = False * seen_ellipsis = False * idx = 0 # <<<<<<<<<<<<<< * for item in tup: * if item is Ellipsis: */ __pyx_v_idx = 0; /* "View.MemoryView":683 * seen_ellipsis = False * idx = 0 * for item in tup: # <<<<<<<<<<<<<< * if item is Ellipsis: * if not seen_ellipsis: */ if (unlikely(__pyx_v_tup == Py_None)) { PyErr_SetString(PyExc_TypeError, "'NoneType' object is not iterable"); __PYX_ERR(1, 683, __pyx_L1_error) } __pyx_t_1 = __pyx_v_tup; __Pyx_INCREF(__pyx_t_1); __pyx_t_4 = 0; for (;;) { { Py_ssize_t __pyx_temp = __Pyx_PyTuple_GET_SIZE(__pyx_t_1); #if !CYTHON_ASSUME_SAFE_MACROS if (unlikely((__pyx_temp < 0))) __PYX_ERR(1, 683, __pyx_L1_error) #endif if (__pyx_t_4 >= __pyx_temp) break; } #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS __pyx_t_3 = PyTuple_GET_ITEM(__pyx_t_1, __pyx_t_4); __Pyx_INCREF(__pyx_t_3); __pyx_t_4++; if (unlikely((0 < 0))) __PYX_ERR(1, 683, __pyx_L1_error) #else __pyx_t_3 = __Pyx_PySequence_ITEM(__pyx_t_1, __pyx_t_4); __pyx_t_4++; if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 683, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); #endif __Pyx_XDECREF_SET(__pyx_v_item, __pyx_t_3); __pyx_t_3 = 0; /* "View.MemoryView":684 * idx = 0 * for item in tup: * if item is Ellipsis: # <<<<<<<<<<<<<< * if not seen_ellipsis: * idx += ndim - len(tup) */ __pyx_t_2 = (__pyx_v_item == __pyx_builtin_Ellipsis); if (__pyx_t_2) { /* "View.MemoryView":685 * for item in tup: * if item is Ellipsis: * if not seen_ellipsis: # <<<<<<<<<<<<<< * idx += ndim - len(tup) * seen_ellipsis = True */ __pyx_t_2 = (!__pyx_v_seen_ellipsis); if (__pyx_t_2) { /* "View.MemoryView":686 * if item is Ellipsis: * if not seen_ellipsis: * idx += ndim - len(tup) # <<<<<<<<<<<<<< * seen_ellipsis = True * have_slices = True */ if (unlikely(__pyx_v_tup == Py_None)) { PyErr_SetString(PyExc_TypeError, "object of type 'NoneType' has no len()"); __PYX_ERR(1, 686, __pyx_L1_error) } __pyx_t_5 = __Pyx_PyTuple_GET_SIZE(__pyx_v_tup); if (unlikely(__pyx_t_5 == ((Py_ssize_t)-1))) __PYX_ERR(1, 686, __pyx_L1_error) __pyx_v_idx = (__pyx_v_idx + (__pyx_v_ndim - __pyx_t_5)); /* "View.MemoryView":687 * if not seen_ellipsis: * idx += ndim - len(tup) * seen_ellipsis = True # <<<<<<<<<<<<<< * have_slices = True * else: */ __pyx_v_seen_ellipsis = 1; /* "View.MemoryView":685 * for item in tup: * if item is Ellipsis: * if not seen_ellipsis: # <<<<<<<<<<<<<< * idx += ndim - len(tup) * seen_ellipsis = True */ } /* "View.MemoryView":688 * idx += ndim - len(tup) * seen_ellipsis = True * have_slices = True # <<<<<<<<<<<<<< * else: * if isinstance(item, slice): */ __pyx_v_have_slices = 1; /* "View.MemoryView":684 * idx = 0 * for item in tup: * if item is Ellipsis: # <<<<<<<<<<<<<< * if not seen_ellipsis: * idx += ndim - len(tup) */ goto __pyx_L5; } /* "View.MemoryView":690 * have_slices = True * else: * if isinstance(item, slice): # <<<<<<<<<<<<<< * have_slices = True * elif not PyIndex_Check(item): */ /*else*/ { __pyx_t_2 = PySlice_Check(__pyx_v_item); if (__pyx_t_2) { /* "View.MemoryView":691 * else: * if isinstance(item, slice): * have_slices = True # <<<<<<<<<<<<<< * elif not PyIndex_Check(item): * raise TypeError, f"Cannot index with type '{type(item)}'" */ __pyx_v_have_slices = 1; /* "View.MemoryView":690 * have_slices = True * else: * if isinstance(item, slice): # <<<<<<<<<<<<<< * have_slices = True * elif not PyIndex_Check(item): */ goto __pyx_L7; } /* "View.MemoryView":692 * if isinstance(item, slice): * have_slices = True * elif not PyIndex_Check(item): # <<<<<<<<<<<<<< * raise TypeError, f"Cannot index with type '{type(item)}'" * result[idx] = item */ __pyx_t_2 = (!(PyIndex_Check(__pyx_v_item) != 0)); if (unlikely(__pyx_t_2)) { /* "View.MemoryView":693 * have_slices = True * elif not PyIndex_Check(item): * raise TypeError, f"Cannot index with type '{type(item)}'" # <<<<<<<<<<<<<< * result[idx] = item * idx += 1 */ __pyx_t_3 = PyTuple_New(3); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 693, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __pyx_t_5 = 0; __pyx_t_6 = 127; __Pyx_INCREF(__pyx_kp_u_Cannot_index_with_type); __pyx_t_5 += 24; __Pyx_GIVEREF(__pyx_kp_u_Cannot_index_with_type); PyTuple_SET_ITEM(__pyx_t_3, 0, __pyx_kp_u_Cannot_index_with_type); __pyx_t_7 = __Pyx_PyObject_FormatSimple(((PyObject *)Py_TYPE(__pyx_v_item)), __pyx_empty_unicode); if (unlikely(!__pyx_t_7)) __PYX_ERR(1, 693, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_7); __pyx_t_6 = (__Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_7) > __pyx_t_6) ? __Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_7) : __pyx_t_6; __pyx_t_5 += __Pyx_PyUnicode_GET_LENGTH(__pyx_t_7); __Pyx_GIVEREF(__pyx_t_7); PyTuple_SET_ITEM(__pyx_t_3, 1, __pyx_t_7); __pyx_t_7 = 0; __Pyx_INCREF(__pyx_kp_u__6); __pyx_t_5 += 1; __Pyx_GIVEREF(__pyx_kp_u__6); PyTuple_SET_ITEM(__pyx_t_3, 2, __pyx_kp_u__6); __pyx_t_7 = __Pyx_PyUnicode_Join(__pyx_t_3, 3, __pyx_t_5, __pyx_t_6); if (unlikely(!__pyx_t_7)) __PYX_ERR(1, 693, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_7); __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; __Pyx_Raise(__pyx_builtin_TypeError, __pyx_t_7, 0, 0); __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; __PYX_ERR(1, 693, __pyx_L1_error) /* "View.MemoryView":692 * if isinstance(item, slice): * have_slices = True * elif not PyIndex_Check(item): # <<<<<<<<<<<<<< * raise TypeError, f"Cannot index with type '{type(item)}'" * result[idx] = item */ } __pyx_L7:; /* "View.MemoryView":694 * elif not PyIndex_Check(item): * raise TypeError, f"Cannot index with type '{type(item)}'" * result[idx] = item # <<<<<<<<<<<<<< * idx += 1 * */ if (unlikely((__Pyx_SetItemInt(__pyx_v_result, __pyx_v_idx, __pyx_v_item, Py_ssize_t, 1, PyInt_FromSsize_t, 1, 1, 1) < 0))) __PYX_ERR(1, 694, __pyx_L1_error) } __pyx_L5:; /* "View.MemoryView":695 * raise TypeError, f"Cannot index with type '{type(item)}'" * result[idx] = item * idx += 1 # <<<<<<<<<<<<<< * * nslices = ndim - idx */ __pyx_v_idx = (__pyx_v_idx + 1); /* "View.MemoryView":683 * seen_ellipsis = False * idx = 0 * for item in tup: # <<<<<<<<<<<<<< * if item is Ellipsis: * if not seen_ellipsis: */ } __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; /* "View.MemoryView":697 * idx += 1 * * nslices = ndim - idx # <<<<<<<<<<<<<< * return have_slices or nslices, tuple(result) * */ __pyx_v_nslices = (__pyx_v_ndim - __pyx_v_idx); /* "View.MemoryView":698 * * nslices = ndim - idx * return have_slices or nslices, tuple(result) # <<<<<<<<<<<<<< * * cdef int assert_direct_dimensions(Py_ssize_t *suboffsets, int ndim) except -1: */ __Pyx_XDECREF(__pyx_r); if (!__pyx_v_have_slices) { } else { __pyx_t_7 = __Pyx_PyBool_FromLong(__pyx_v_have_slices); if (unlikely(!__pyx_t_7)) __PYX_ERR(1, 698, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_7); __pyx_t_1 = __pyx_t_7; __pyx_t_7 = 0; goto __pyx_L9_bool_binop_done; } __pyx_t_7 = PyInt_FromSsize_t(__pyx_v_nslices); if (unlikely(!__pyx_t_7)) __PYX_ERR(1, 698, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_7); __pyx_t_1 = __pyx_t_7; __pyx_t_7 = 0; __pyx_L9_bool_binop_done:; __pyx_t_7 = PyList_AsTuple(__pyx_v_result); if (unlikely(!__pyx_t_7)) __PYX_ERR(1, 698, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_7); __pyx_t_3 = PyTuple_New(2); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 698, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __Pyx_GIVEREF(__pyx_t_1); if (__Pyx_PyTuple_SET_ITEM(__pyx_t_3, 0, __pyx_t_1)) __PYX_ERR(1, 698, __pyx_L1_error); __Pyx_GIVEREF(__pyx_t_7); if (__Pyx_PyTuple_SET_ITEM(__pyx_t_3, 1, __pyx_t_7)) __PYX_ERR(1, 698, __pyx_L1_error); __pyx_t_1 = 0; __pyx_t_7 = 0; __pyx_r = ((PyObject*)__pyx_t_3); __pyx_t_3 = 0; goto __pyx_L0; /* "View.MemoryView":671 * 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_1); __Pyx_XDECREF(__pyx_t_3); __Pyx_XDECREF(__pyx_t_7); __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_item); __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "View.MemoryView":700 * return have_slices or nslices, tuple(result) * * cdef int assert_direct_dimensions(Py_ssize_t *suboffsets, int ndim) except -1: # <<<<<<<<<<<<<< * for suboffset in suboffsets[:ndim]: * if suboffset >= 0: */ static int assert_direct_dimensions(Py_ssize_t *__pyx_v_suboffsets, int __pyx_v_ndim) { Py_ssize_t __pyx_v_suboffset; int __pyx_r; Py_ssize_t *__pyx_t_1; Py_ssize_t *__pyx_t_2; Py_ssize_t *__pyx_t_3; int __pyx_t_4; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; /* "View.MemoryView":701 * * cdef int assert_direct_dimensions(Py_ssize_t *suboffsets, int ndim) except -1: * 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":702 * cdef int assert_direct_dimensions(Py_ssize_t *suboffsets, int ndim) except -1: * for suboffset in suboffsets[:ndim]: * if suboffset >= 0: # <<<<<<<<<<<<<< * raise ValueError, "Indirect dimensions not supported" * return 0 # return type just used as an error flag */ __pyx_t_4 = (__pyx_v_suboffset >= 0); if (unlikely(__pyx_t_4)) { /* "View.MemoryView":703 * for suboffset in suboffsets[:ndim]: * if suboffset >= 0: * raise ValueError, "Indirect dimensions not supported" # <<<<<<<<<<<<<< * return 0 # return type just used as an error flag * */ __Pyx_Raise(__pyx_builtin_ValueError, __pyx_kp_s_Indirect_dimensions_not_supporte, 0, 0); __PYX_ERR(1, 703, __pyx_L1_error) /* "View.MemoryView":702 * cdef int assert_direct_dimensions(Py_ssize_t *suboffsets, int ndim) except -1: * for suboffset in suboffsets[:ndim]: * if suboffset >= 0: # <<<<<<<<<<<<<< * raise ValueError, "Indirect dimensions not supported" * return 0 # return type just used as an error flag */ } } /* "View.MemoryView":704 * if suboffset >= 0: * raise ValueError, "Indirect dimensions not supported" * return 0 # return type just used as an error flag # <<<<<<<<<<<<<< * * */ __pyx_r = 0; goto __pyx_L0; /* "View.MemoryView":700 * return have_slices or nslices, tuple(result) * * cdef int assert_direct_dimensions(Py_ssize_t *suboffsets, int ndim) except -1: # <<<<<<<<<<<<<< * for suboffset in suboffsets[:ndim]: * if suboffset >= 0: */ /* function exit code */ __pyx_L1_error:; __Pyx_AddTraceback("View.MemoryView.assert_direct_dimensions", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = -1; __pyx_L0:; return __pyx_r; } /* "View.MemoryView":711 * * @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; Py_ssize_t __pyx_v_cindex; 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; PyObject *__pyx_t_2 = NULL; struct __pyx_memoryview_obj *__pyx_t_3; char *__pyx_t_4; int __pyx_t_5; Py_ssize_t __pyx_t_6; PyObject *(*__pyx_t_7)(PyObject *); PyObject *__pyx_t_8 = NULL; Py_ssize_t __pyx_t_9; int __pyx_t_10; Py_ssize_t __pyx_t_11; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("memview_slice", 1); /* "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 * cdef __Pyx_memviewslice src, dst */ __pyx_v_new_ndim = 0; __pyx_v_suboffset_dim = -1; /* "View.MemoryView":719 * * * memset(&dst, 0, sizeof(dst)) # <<<<<<<<<<<<<< * * cdef _memoryviewslice memviewsliceobj */ (void)(memset((&__pyx_v_dst), 0, (sizeof(__pyx_v_dst)))); /* "View.MemoryView":723 * cdef _memoryviewslice memviewsliceobj * * assert memview.view.ndim > 0 # <<<<<<<<<<<<<< * * if isinstance(memview, _memoryviewslice): */ #ifndef CYTHON_WITHOUT_ASSERTIONS if (unlikely(__pyx_assertions_enabled())) { __pyx_t_1 = (__pyx_v_memview->view.ndim > 0); if (unlikely(!__pyx_t_1)) { __Pyx_Raise(__pyx_builtin_AssertionError, 0, 0, 0); __PYX_ERR(1, 723, __pyx_L1_error) } } #else if ((1)); else __PYX_ERR(1, 723, __pyx_L1_error) #endif /* "View.MemoryView":725 * 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); if (__pyx_t_1) { /* "View.MemoryView":726 * * 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, 726, __pyx_L1_error) __pyx_t_2 = ((PyObject *)__pyx_v_memview); __Pyx_INCREF(__pyx_t_2); __pyx_v_memviewsliceobj = ((struct __pyx_memoryviewslice_obj *)__pyx_t_2); __pyx_t_2 = 0; /* "View.MemoryView":727 * 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":725 * assert memview.view.ndim > 0 * * if isinstance(memview, _memoryviewslice): # <<<<<<<<<<<<<< * memviewsliceobj = memview * p_src = &memviewsliceobj.from_slice */ goto __pyx_L3; } /* "View.MemoryView":729 * 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":730 * else: * slice_copy(memview, &src) * p_src = &src # <<<<<<<<<<<<<< * * */ __pyx_v_p_src = (&__pyx_v_src); } __pyx_L3:; /* "View.MemoryView":736 * * * dst.memview = p_src.memview # <<<<<<<<<<<<<< * dst.data = p_src.data * */ __pyx_t_3 = __pyx_v_p_src->memview; __pyx_v_dst.memview = __pyx_t_3; /* "View.MemoryView":737 * * dst.memview = p_src.memview * dst.data = p_src.data # <<<<<<<<<<<<<< * * */ __pyx_t_4 = __pyx_v_p_src->data; __pyx_v_dst.data = __pyx_t_4; /* "View.MemoryView":742 * * * cdef __Pyx_memviewslice *p_dst = &dst # <<<<<<<<<<<<<< * cdef int *p_suboffset_dim = &suboffset_dim * cdef Py_ssize_t start, stop, step, cindex */ __pyx_v_p_dst = (&__pyx_v_dst); /* "View.MemoryView":743 * * cdef __Pyx_memviewslice *p_dst = &dst * cdef int *p_suboffset_dim = &suboffset_dim # <<<<<<<<<<<<<< * cdef Py_ssize_t start, stop, step, cindex * cdef bint have_start, have_stop, have_step */ __pyx_v_p_suboffset_dim = (&__pyx_v_suboffset_dim); /* "View.MemoryView":747 * cdef bint have_start, have_stop, have_step * * for dim, index in enumerate(indices): # <<<<<<<<<<<<<< * if PyIndex_Check(index): * cindex = index */ __pyx_t_5 = 0; if (likely(PyList_CheckExact(__pyx_v_indices)) || PyTuple_CheckExact(__pyx_v_indices)) { __pyx_t_2 = __pyx_v_indices; __Pyx_INCREF(__pyx_t_2); __pyx_t_6 = 0; __pyx_t_7 = NULL; } else { __pyx_t_6 = -1; __pyx_t_2 = PyObject_GetIter(__pyx_v_indices); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 747, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __pyx_t_7 = __Pyx_PyObject_GetIterNextFunc(__pyx_t_2); if (unlikely(!__pyx_t_7)) __PYX_ERR(1, 747, __pyx_L1_error) } for (;;) { if (likely(!__pyx_t_7)) { if (likely(PyList_CheckExact(__pyx_t_2))) { { Py_ssize_t __pyx_temp = __Pyx_PyList_GET_SIZE(__pyx_t_2); #if !CYTHON_ASSUME_SAFE_MACROS if (unlikely((__pyx_temp < 0))) __PYX_ERR(1, 747, __pyx_L1_error) #endif if (__pyx_t_6 >= __pyx_temp) break; } #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS __pyx_t_8 = PyList_GET_ITEM(__pyx_t_2, __pyx_t_6); __Pyx_INCREF(__pyx_t_8); __pyx_t_6++; if (unlikely((0 < 0))) __PYX_ERR(1, 747, __pyx_L1_error) #else __pyx_t_8 = __Pyx_PySequence_ITEM(__pyx_t_2, __pyx_t_6); __pyx_t_6++; if (unlikely(!__pyx_t_8)) __PYX_ERR(1, 747, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_8); #endif } else { { Py_ssize_t __pyx_temp = __Pyx_PyTuple_GET_SIZE(__pyx_t_2); #if !CYTHON_ASSUME_SAFE_MACROS if (unlikely((__pyx_temp < 0))) __PYX_ERR(1, 747, __pyx_L1_error) #endif if (__pyx_t_6 >= __pyx_temp) break; } #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS __pyx_t_8 = PyTuple_GET_ITEM(__pyx_t_2, __pyx_t_6); __Pyx_INCREF(__pyx_t_8); __pyx_t_6++; if (unlikely((0 < 0))) __PYX_ERR(1, 747, __pyx_L1_error) #else __pyx_t_8 = __Pyx_PySequence_ITEM(__pyx_t_2, __pyx_t_6); __pyx_t_6++; if (unlikely(!__pyx_t_8)) __PYX_ERR(1, 747, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_8); #endif } } else { __pyx_t_8 = __pyx_t_7(__pyx_t_2); if (unlikely(!__pyx_t_8)) { PyObject* exc_type = PyErr_Occurred(); if (exc_type) { if (likely(__Pyx_PyErr_GivenExceptionMatches(exc_type, PyExc_StopIteration))) PyErr_Clear(); else __PYX_ERR(1, 747, __pyx_L1_error) } break; } __Pyx_GOTREF(__pyx_t_8); } __Pyx_XDECREF_SET(__pyx_v_index, __pyx_t_8); __pyx_t_8 = 0; __pyx_v_dim = __pyx_t_5; __pyx_t_5 = (__pyx_t_5 + 1); /* "View.MemoryView":748 * * for dim, index in enumerate(indices): * if PyIndex_Check(index): # <<<<<<<<<<<<<< * cindex = index * slice_memviewslice( */ __pyx_t_1 = (PyIndex_Check(__pyx_v_index) != 0); if (__pyx_t_1) { /* "View.MemoryView":749 * for dim, index in enumerate(indices): * if PyIndex_Check(index): * cindex = index # <<<<<<<<<<<<<< * slice_memviewslice( * p_dst, p_src.shape[dim], p_src.strides[dim], p_src.suboffsets[dim], */ __pyx_t_9 = __Pyx_PyIndex_AsSsize_t(__pyx_v_index); if (unlikely((__pyx_t_9 == (Py_ssize_t)-1) && PyErr_Occurred())) __PYX_ERR(1, 749, __pyx_L1_error) __pyx_v_cindex = __pyx_t_9; /* "View.MemoryView":750 * if PyIndex_Check(index): * cindex = 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_10 = __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_cindex, 0, 0, 0, 0, 0, 0); if (unlikely(__pyx_t_10 == ((int)-1))) __PYX_ERR(1, 750, __pyx_L1_error) /* "View.MemoryView":748 * * for dim, index in enumerate(indices): * if PyIndex_Check(index): # <<<<<<<<<<<<<< * cindex = index * slice_memviewslice( */ 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_1 = (__pyx_v_index == Py_None); 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_8 = __Pyx_PyObject_GetAttrStr(__pyx_v_index, __pyx_n_s_start); if (unlikely(!__pyx_t_8)) __PYX_ERR(1, 762, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_8); __pyx_t_1 = __Pyx_PyObject_IsTrue(__pyx_t_8); if (unlikely((__pyx_t_1 < 0))) __PYX_ERR(1, 762, __pyx_L1_error) if (!__pyx_t_1) { __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; } else { __pyx_t_11 = __Pyx_PyIndex_AsSsize_t(__pyx_t_8); if (unlikely((__pyx_t_11 == (Py_ssize_t)-1) && PyErr_Occurred())) __PYX_ERR(1, 762, __pyx_L1_error) __pyx_t_9 = __pyx_t_11; __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; goto __pyx_L7_bool_binop_done; } __pyx_t_9 = 0; __pyx_L7_bool_binop_done:; __pyx_v_start = __pyx_t_9; /* "View.MemoryView":763 * else: * start = index.start or 0 * stop = index.stop or 0 # <<<<<<<<<<<<<< * step = index.step or 0 * */ __pyx_t_8 = __Pyx_PyObject_GetAttrStr(__pyx_v_index, __pyx_n_s_stop); if (unlikely(!__pyx_t_8)) __PYX_ERR(1, 763, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_8); __pyx_t_1 = __Pyx_PyObject_IsTrue(__pyx_t_8); if (unlikely((__pyx_t_1 < 0))) __PYX_ERR(1, 763, __pyx_L1_error) if (!__pyx_t_1) { __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; } else { __pyx_t_11 = __Pyx_PyIndex_AsSsize_t(__pyx_t_8); if (unlikely((__pyx_t_11 == (Py_ssize_t)-1) && PyErr_Occurred())) __PYX_ERR(1, 763, __pyx_L1_error) __pyx_t_9 = __pyx_t_11; __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; goto __pyx_L9_bool_binop_done; } __pyx_t_9 = 0; __pyx_L9_bool_binop_done:; __pyx_v_stop = __pyx_t_9; /* "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_8 = __Pyx_PyObject_GetAttrStr(__pyx_v_index, __pyx_n_s_step); if (unlikely(!__pyx_t_8)) __PYX_ERR(1, 764, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_8); __pyx_t_1 = __Pyx_PyObject_IsTrue(__pyx_t_8); if (unlikely((__pyx_t_1 < 0))) __PYX_ERR(1, 764, __pyx_L1_error) if (!__pyx_t_1) { __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; } else { __pyx_t_11 = __Pyx_PyIndex_AsSsize_t(__pyx_t_8); if (unlikely((__pyx_t_11 == (Py_ssize_t)-1) && PyErr_Occurred())) __PYX_ERR(1, 764, __pyx_L1_error) __pyx_t_9 = __pyx_t_11; __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; goto __pyx_L11_bool_binop_done; } __pyx_t_9 = 0; __pyx_L11_bool_binop_done:; __pyx_v_step = __pyx_t_9; /* "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_8 = __Pyx_PyObject_GetAttrStr(__pyx_v_index, __pyx_n_s_start); if (unlikely(!__pyx_t_8)) __PYX_ERR(1, 766, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_8); __pyx_t_1 = (__pyx_t_8 != Py_None); __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 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_8 = __Pyx_PyObject_GetAttrStr(__pyx_v_index, __pyx_n_s_stop); if (unlikely(!__pyx_t_8)) __PYX_ERR(1, 767, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_8); __pyx_t_1 = (__pyx_t_8 != Py_None); __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 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_8 = __Pyx_PyObject_GetAttrStr(__pyx_v_index, __pyx_n_s_step); if (unlikely(!__pyx_t_8)) __PYX_ERR(1, 768, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_8); __pyx_t_1 = (__pyx_t_8 != Py_None); __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 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_10 = __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_10 == ((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":747 * cdef bint have_start, have_stop, have_step * * for dim, index in enumerate(indices): # <<<<<<<<<<<<<< * if PyIndex_Check(index): * cindex = index */ } __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 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); if (__pyx_t_1) { /* "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_2 = __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_2)) __PYX_ERR(1, 779, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); if (!(likely(((__pyx_t_2) == Py_None) || likely(__Pyx_TypeTest(__pyx_t_2, __pyx_memoryview_type))))) __PYX_ERR(1, 779, __pyx_L1_error) __pyx_r = ((struct __pyx_memoryview_obj *)__pyx_t_2); __pyx_t_2 = 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_2 = __pyx_memoryview_fromslice(__pyx_v_dst, __pyx_v_new_ndim, NULL, NULL, __pyx_v_memview->dtype_is_object); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 784, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); /* "View.MemoryView":784 * memview.dtype_is_object) * else: * return memoryview_fromslice(dst, new_ndim, NULL, NULL, # <<<<<<<<<<<<<< * memview.dtype_is_object) * */ if (!(likely(((__pyx_t_2) == Py_None) || likely(__Pyx_TypeTest(__pyx_t_2, __pyx_memoryview_type))))) __PYX_ERR(1, 784, __pyx_L1_error) __pyx_r = ((struct __pyx_memoryview_obj *)__pyx_t_2); __pyx_t_2 = 0; goto __pyx_L0; } /* "View.MemoryView":711 * * @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_2); __Pyx_XDECREF(__pyx_t_8); __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":793 * * @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; #ifdef WITH_THREAD PyGILState_STATE __pyx_gilstate_save; #endif /* "View.MemoryView":813 * cdef bint negative_step * * if not is_slice: # <<<<<<<<<<<<<< * * if start < 0: */ __pyx_t_1 = (!__pyx_v_is_slice); if (__pyx_t_1) { /* "View.MemoryView":815 * if not is_slice: * * if start < 0: # <<<<<<<<<<<<<< * start += shape * if not 0 <= start < shape: */ __pyx_t_1 = (__pyx_v_start < 0); if (__pyx_t_1) { /* "View.MemoryView":816 * * if start < 0: * start += shape # <<<<<<<<<<<<<< * if not 0 <= start < shape: * _err_dim(PyExc_IndexError, "Index out of bounds (axis %d)", dim) */ __pyx_v_start = (__pyx_v_start + __pyx_v_shape); /* "View.MemoryView":815 * if not is_slice: * * if start < 0: # <<<<<<<<<<<<<< * start += shape * if not 0 <= start < shape: */ } /* "View.MemoryView":817 * if start < 0: * start += shape * if not 0 <= start < shape: # <<<<<<<<<<<<<< * _err_dim(PyExc_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); if (__pyx_t_2) { /* "View.MemoryView":818 * start += shape * if not 0 <= start < shape: * _err_dim(PyExc_IndexError, "Index out of bounds (axis %d)", dim) # <<<<<<<<<<<<<< * else: * */ __pyx_t_3 = __pyx_memoryview_err_dim(PyExc_IndexError, __pyx_kp_s_Index_out_of_bounds_axis_d, __pyx_v_dim); if (unlikely(__pyx_t_3 == ((int)-1))) __PYX_ERR(1, 818, __pyx_L1_error) /* "View.MemoryView":817 * if start < 0: * start += shape * if not 0 <= start < shape: # <<<<<<<<<<<<<< * _err_dim(PyExc_IndexError, "Index out of bounds (axis %d)", dim) * else: */ } /* "View.MemoryView":813 * cdef bint negative_step * * if not is_slice: # <<<<<<<<<<<<<< * * if start < 0: */ goto __pyx_L3; } /* "View.MemoryView":821 * else: * * if have_step: # <<<<<<<<<<<<<< * negative_step = step < 0 * if step == 0: */ /*else*/ { __pyx_t_2 = (__pyx_v_have_step != 0); if (__pyx_t_2) { /* "View.MemoryView":822 * * if have_step: * negative_step = step < 0 # <<<<<<<<<<<<<< * if step == 0: * _err_dim(PyExc_ValueError, "Step may not be zero (axis %d)", dim) */ __pyx_v_negative_step = (__pyx_v_step < 0); /* "View.MemoryView":823 * if have_step: * negative_step = step < 0 * if step == 0: # <<<<<<<<<<<<<< * _err_dim(PyExc_ValueError, "Step may not be zero (axis %d)", dim) * else: */ __pyx_t_2 = (__pyx_v_step == 0); if (__pyx_t_2) { /* "View.MemoryView":824 * negative_step = step < 0 * if step == 0: * _err_dim(PyExc_ValueError, "Step may not be zero (axis %d)", dim) # <<<<<<<<<<<<<< * else: * negative_step = False */ __pyx_t_3 = __pyx_memoryview_err_dim(PyExc_ValueError, __pyx_kp_s_Step_may_not_be_zero_axis_d, __pyx_v_dim); if (unlikely(__pyx_t_3 == ((int)-1))) __PYX_ERR(1, 824, __pyx_L1_error) /* "View.MemoryView":823 * if have_step: * negative_step = step < 0 * if step == 0: # <<<<<<<<<<<<<< * _err_dim(PyExc_ValueError, "Step may not be zero (axis %d)", dim) * else: */ } /* "View.MemoryView":821 * else: * * if have_step: # <<<<<<<<<<<<<< * negative_step = step < 0 * if step == 0: */ goto __pyx_L6; } /* "View.MemoryView":826 * _err_dim(PyExc_ValueError, "Step may not be zero (axis %d)", dim) * else: * negative_step = False # <<<<<<<<<<<<<< * step = 1 * */ /*else*/ { __pyx_v_negative_step = 0; /* "View.MemoryView":827 * else: * negative_step = False * step = 1 # <<<<<<<<<<<<<< * * */ __pyx_v_step = 1; } __pyx_L6:; /* "View.MemoryView":830 * * * if have_start: # <<<<<<<<<<<<<< * if start < 0: * start += shape */ __pyx_t_2 = (__pyx_v_have_start != 0); if (__pyx_t_2) { /* "View.MemoryView":831 * * if have_start: * if start < 0: # <<<<<<<<<<<<<< * start += shape * if start < 0: */ __pyx_t_2 = (__pyx_v_start < 0); if (__pyx_t_2) { /* "View.MemoryView":832 * if have_start: * if start < 0: * start += shape # <<<<<<<<<<<<<< * if start < 0: * start = 0 */ __pyx_v_start = (__pyx_v_start + __pyx_v_shape); /* "View.MemoryView":833 * if start < 0: * start += shape * if start < 0: # <<<<<<<<<<<<<< * start = 0 * elif start >= shape: */ __pyx_t_2 = (__pyx_v_start < 0); if (__pyx_t_2) { /* "View.MemoryView":834 * start += shape * if start < 0: * start = 0 # <<<<<<<<<<<<<< * elif start >= shape: * if negative_step: */ __pyx_v_start = 0; /* "View.MemoryView":833 * if start < 0: * start += shape * if start < 0: # <<<<<<<<<<<<<< * start = 0 * elif start >= shape: */ } /* "View.MemoryView":831 * * if have_start: * if start < 0: # <<<<<<<<<<<<<< * start += shape * if start < 0: */ goto __pyx_L9; } /* "View.MemoryView":835 * if start < 0: * start = 0 * elif start >= shape: # <<<<<<<<<<<<<< * if negative_step: * start = shape - 1 */ __pyx_t_2 = (__pyx_v_start >= __pyx_v_shape); if (__pyx_t_2) { /* "View.MemoryView":836 * start = 0 * elif start >= shape: * if negative_step: # <<<<<<<<<<<<<< * start = shape - 1 * else: */ if (__pyx_v_negative_step) { /* "View.MemoryView":837 * elif start >= shape: * if negative_step: * start = shape - 1 # <<<<<<<<<<<<<< * else: * start = shape */ __pyx_v_start = (__pyx_v_shape - 1); /* "View.MemoryView":836 * start = 0 * elif start >= shape: * if negative_step: # <<<<<<<<<<<<<< * start = shape - 1 * else: */ goto __pyx_L11; } /* "View.MemoryView":839 * start = shape - 1 * else: * start = shape # <<<<<<<<<<<<<< * else: * if negative_step: */ /*else*/ { __pyx_v_start = __pyx_v_shape; } __pyx_L11:; /* "View.MemoryView":835 * if start < 0: * start = 0 * elif start >= shape: # <<<<<<<<<<<<<< * if negative_step: * start = shape - 1 */ } __pyx_L9:; /* "View.MemoryView":830 * * * if have_start: # <<<<<<<<<<<<<< * if start < 0: * start += shape */ goto __pyx_L8; } /* "View.MemoryView":841 * start = shape * else: * if negative_step: # <<<<<<<<<<<<<< * start = shape - 1 * else: */ /*else*/ { if (__pyx_v_negative_step) { /* "View.MemoryView":842 * else: * if negative_step: * start = shape - 1 # <<<<<<<<<<<<<< * else: * start = 0 */ __pyx_v_start = (__pyx_v_shape - 1); /* "View.MemoryView":841 * start = shape * else: * if negative_step: # <<<<<<<<<<<<<< * start = shape - 1 * else: */ goto __pyx_L12; } /* "View.MemoryView":844 * start = shape - 1 * else: * start = 0 # <<<<<<<<<<<<<< * * if have_stop: */ /*else*/ { __pyx_v_start = 0; } __pyx_L12:; } __pyx_L8:; /* "View.MemoryView":846 * start = 0 * * if have_stop: # <<<<<<<<<<<<<< * if stop < 0: * stop += shape */ __pyx_t_2 = (__pyx_v_have_stop != 0); if (__pyx_t_2) { /* "View.MemoryView":847 * * if have_stop: * if stop < 0: # <<<<<<<<<<<<<< * stop += shape * if stop < 0: */ __pyx_t_2 = (__pyx_v_stop < 0); if (__pyx_t_2) { /* "View.MemoryView":848 * if have_stop: * if stop < 0: * stop += shape # <<<<<<<<<<<<<< * if stop < 0: * stop = 0 */ __pyx_v_stop = (__pyx_v_stop + __pyx_v_shape); /* "View.MemoryView":849 * if stop < 0: * stop += shape * if stop < 0: # <<<<<<<<<<<<<< * stop = 0 * elif stop > shape: */ __pyx_t_2 = (__pyx_v_stop < 0); if (__pyx_t_2) { /* "View.MemoryView":850 * stop += shape * if stop < 0: * stop = 0 # <<<<<<<<<<<<<< * elif stop > shape: * stop = shape */ __pyx_v_stop = 0; /* "View.MemoryView":849 * if stop < 0: * stop += shape * if stop < 0: # <<<<<<<<<<<<<< * stop = 0 * elif stop > shape: */ } /* "View.MemoryView":847 * * if have_stop: * if stop < 0: # <<<<<<<<<<<<<< * stop += shape * if stop < 0: */ goto __pyx_L14; } /* "View.MemoryView":851 * if stop < 0: * stop = 0 * elif stop > shape: # <<<<<<<<<<<<<< * stop = shape * else: */ __pyx_t_2 = (__pyx_v_stop > __pyx_v_shape); if (__pyx_t_2) { /* "View.MemoryView":852 * stop = 0 * elif stop > shape: * stop = shape # <<<<<<<<<<<<<< * else: * if negative_step: */ __pyx_v_stop = __pyx_v_shape; /* "View.MemoryView":851 * if stop < 0: * stop = 0 * elif stop > shape: # <<<<<<<<<<<<<< * stop = shape * else: */ } __pyx_L14:; /* "View.MemoryView":846 * start = 0 * * if have_stop: # <<<<<<<<<<<<<< * if stop < 0: * stop += shape */ goto __pyx_L13; } /* "View.MemoryView":854 * stop = shape * else: * if negative_step: # <<<<<<<<<<<<<< * stop = -1 * else: */ /*else*/ { if (__pyx_v_negative_step) { /* "View.MemoryView":855 * else: * if negative_step: * stop = -1 # <<<<<<<<<<<<<< * else: * stop = shape */ __pyx_v_stop = -1L; /* "View.MemoryView":854 * stop = shape * else: * if negative_step: # <<<<<<<<<<<<<< * stop = -1 * else: */ goto __pyx_L16; } /* "View.MemoryView":857 * stop = -1 * else: * stop = shape # <<<<<<<<<<<<<< * * */ /*else*/ { __pyx_v_stop = __pyx_v_shape; } __pyx_L16:; } __pyx_L13:; /* "View.MemoryView":861 * * 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":863 * 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":864 * * if (stop - start) - step * new_shape: * new_shape += 1 # <<<<<<<<<<<<<< * * if new_shape < 0: */ __pyx_v_new_shape = (__pyx_v_new_shape + 1); /* "View.MemoryView":863 * new_shape = (stop - start) // step * * if (stop - start) - step * new_shape: # <<<<<<<<<<<<<< * new_shape += 1 * */ } /* "View.MemoryView":866 * new_shape += 1 * * if new_shape < 0: # <<<<<<<<<<<<<< * new_shape = 0 * */ __pyx_t_2 = (__pyx_v_new_shape < 0); if (__pyx_t_2) { /* "View.MemoryView":867 * * if new_shape < 0: * new_shape = 0 # <<<<<<<<<<<<<< * * */ __pyx_v_new_shape = 0; /* "View.MemoryView":866 * new_shape += 1 * * if new_shape < 0: # <<<<<<<<<<<<<< * new_shape = 0 * */ } /* "View.MemoryView":870 * * * 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":871 * * 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":872 * 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":875 * * * if suboffset_dim[0] < 0: # <<<<<<<<<<<<<< * dst.data += start * stride * else: */ __pyx_t_2 = ((__pyx_v_suboffset_dim[0]) < 0); if (__pyx_t_2) { /* "View.MemoryView":876 * * 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":875 * * * if suboffset_dim[0] < 0: # <<<<<<<<<<<<<< * dst.data += start * stride * else: */ goto __pyx_L19; } /* "View.MemoryView":878 * 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_L19:; /* "View.MemoryView":880 * 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); if (__pyx_t_2) { /* "View.MemoryView":881 * * if suboffset >= 0: * if not is_slice: # <<<<<<<<<<<<<< * if new_ndim == 0: * dst.data = ( dst.data)[0] + suboffset */ __pyx_t_2 = (!__pyx_v_is_slice); if (__pyx_t_2) { /* "View.MemoryView":882 * 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); if (__pyx_t_2) { /* "View.MemoryView":883 * if not is_slice: * if new_ndim == 0: * dst.data = ( dst.data)[0] + suboffset # <<<<<<<<<<<<<< * else: * _err_dim(PyExc_IndexError, "All dimensions preceding dimension %d " */ __pyx_v_dst->data = ((((char **)__pyx_v_dst->data)[0]) + __pyx_v_suboffset); /* "View.MemoryView":882 * if suboffset >= 0: * if not is_slice: * if new_ndim == 0: # <<<<<<<<<<<<<< * dst.data = ( dst.data)[0] + suboffset * else: */ goto __pyx_L22; } /* "View.MemoryView":885 * dst.data = ( dst.data)[0] + suboffset * else: * _err_dim(PyExc_IndexError, "All dimensions preceding dimension %d " # <<<<<<<<<<<<<< * "must be indexed and not sliced", dim) * else: */ /*else*/ { /* "View.MemoryView":886 * else: * _err_dim(PyExc_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(PyExc_IndexError, __pyx_kp_s_All_dimensions_preceding_dimensi, __pyx_v_dim); if (unlikely(__pyx_t_3 == ((int)-1))) __PYX_ERR(1, 885, __pyx_L1_error) } __pyx_L22:; /* "View.MemoryView":881 * * if suboffset >= 0: * if not is_slice: # <<<<<<<<<<<<<< * if new_ndim == 0: * dst.data = ( dst.data)[0] + suboffset */ goto __pyx_L21; } /* "View.MemoryView":888 * "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_L21:; /* "View.MemoryView":880 * dst.suboffsets[suboffset_dim[0]] += start * stride * * if suboffset >= 0: # <<<<<<<<<<<<<< * if not is_slice: * if new_ndim == 0: */ } /* "View.MemoryView":890 * suboffset_dim[0] = new_ndim * * return 0 # <<<<<<<<<<<<<< * * */ __pyx_r = 0; goto __pyx_L0; /* "View.MemoryView":793 * * @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 __pyx_gilstate_save = __Pyx_PyGILState_Ensure(); #endif __Pyx_AddTraceback("View.MemoryView.slice_memviewslice", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = -1; #ifdef WITH_THREAD __Pyx_PyGILState_Release(__pyx_gilstate_save); #endif __pyx_L0:; return __pyx_r; } /* "View.MemoryView":896 * * @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; Py_UCS4 __pyx_t_4; PyObject *__pyx_t_5 = NULL; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("pybuffer_index", 1); /* "View.MemoryView":898 * 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":899 * 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":902 * cdef char *resultp * * if view.ndim == 0: # <<<<<<<<<<<<<< * shape = view.len // itemsize * stride = itemsize */ __pyx_t_2 = (__pyx_v_view->ndim == 0); if (__pyx_t_2) { /* "View.MemoryView":903 * * 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, 903, __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(__Pyx_UNARY_NEG_WOULD_OVERFLOW(__pyx_v_view->len))) { PyErr_SetString(PyExc_OverflowError, "value too large to perform division"); __PYX_ERR(1, 903, __pyx_L1_error) } __pyx_v_shape = __Pyx_div_Py_ssize_t(__pyx_v_view->len, __pyx_v_itemsize); /* "View.MemoryView":904 * if view.ndim == 0: * shape = view.len // itemsize * stride = itemsize # <<<<<<<<<<<<<< * else: * shape = view.shape[dim] */ __pyx_v_stride = __pyx_v_itemsize; /* "View.MemoryView":902 * cdef char *resultp * * if view.ndim == 0: # <<<<<<<<<<<<<< * shape = view.len // itemsize * stride = itemsize */ goto __pyx_L3; } /* "View.MemoryView":906 * 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":907 * 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":908 * shape = view.shape[dim] * stride = view.strides[dim] * if view.suboffsets != NULL: # <<<<<<<<<<<<<< * suboffset = view.suboffsets[dim] * */ __pyx_t_2 = (__pyx_v_view->suboffsets != NULL); if (__pyx_t_2) { /* "View.MemoryView":909 * 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":908 * shape = view.shape[dim] * stride = view.strides[dim] * if view.suboffsets != NULL: # <<<<<<<<<<<<<< * suboffset = view.suboffsets[dim] * */ } } __pyx_L3:; /* "View.MemoryView":911 * suboffset = view.suboffsets[dim] * * if index < 0: # <<<<<<<<<<<<<< * index += view.shape[dim] * if index < 0: */ __pyx_t_2 = (__pyx_v_index < 0); if (__pyx_t_2) { /* "View.MemoryView":912 * * if index < 0: * index += view.shape[dim] # <<<<<<<<<<<<<< * if index < 0: * raise IndexError, f"Out of bounds on buffer access (axis {dim})" */ __pyx_v_index = (__pyx_v_index + (__pyx_v_view->shape[__pyx_v_dim])); /* "View.MemoryView":913 * if index < 0: * index += view.shape[dim] * if index < 0: # <<<<<<<<<<<<<< * raise IndexError, f"Out of bounds on buffer access (axis {dim})" * */ __pyx_t_2 = (__pyx_v_index < 0); if (unlikely(__pyx_t_2)) { /* "View.MemoryView":914 * index += view.shape[dim] * if index < 0: * raise IndexError, f"Out of bounds on buffer access (axis {dim})" # <<<<<<<<<<<<<< * * if index >= shape: */ __pyx_t_3 = PyTuple_New(3); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 914, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __pyx_t_1 = 0; __pyx_t_4 = 127; __Pyx_INCREF(__pyx_kp_u_Out_of_bounds_on_buffer_access_a); __pyx_t_1 += 37; __Pyx_GIVEREF(__pyx_kp_u_Out_of_bounds_on_buffer_access_a); PyTuple_SET_ITEM(__pyx_t_3, 0, __pyx_kp_u_Out_of_bounds_on_buffer_access_a); __pyx_t_5 = __Pyx_PyUnicode_From_Py_ssize_t(__pyx_v_dim, 0, ' ', 'd'); if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 914, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_5); __pyx_t_1 += __Pyx_PyUnicode_GET_LENGTH(__pyx_t_5); __Pyx_GIVEREF(__pyx_t_5); PyTuple_SET_ITEM(__pyx_t_3, 1, __pyx_t_5); __pyx_t_5 = 0; __Pyx_INCREF(__pyx_kp_u__7); __pyx_t_1 += 1; __Pyx_GIVEREF(__pyx_kp_u__7); PyTuple_SET_ITEM(__pyx_t_3, 2, __pyx_kp_u__7); __pyx_t_5 = __Pyx_PyUnicode_Join(__pyx_t_3, 3, __pyx_t_1, __pyx_t_4); if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 914, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_5); __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; __Pyx_Raise(__pyx_builtin_IndexError, __pyx_t_5, 0, 0); __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; __PYX_ERR(1, 914, __pyx_L1_error) /* "View.MemoryView":913 * if index < 0: * index += view.shape[dim] * if index < 0: # <<<<<<<<<<<<<< * raise IndexError, f"Out of bounds on buffer access (axis {dim})" * */ } /* "View.MemoryView":911 * suboffset = view.suboffsets[dim] * * if index < 0: # <<<<<<<<<<<<<< * index += view.shape[dim] * if index < 0: */ } /* "View.MemoryView":916 * raise IndexError, f"Out of bounds on buffer access (axis {dim})" * * if index >= shape: # <<<<<<<<<<<<<< * raise IndexError, f"Out of bounds on buffer access (axis {dim})" * */ __pyx_t_2 = (__pyx_v_index >= __pyx_v_shape); if (unlikely(__pyx_t_2)) { /* "View.MemoryView":917 * * if index >= shape: * raise IndexError, f"Out of bounds on buffer access (axis {dim})" # <<<<<<<<<<<<<< * * resultp = bufp + index * stride */ __pyx_t_5 = PyTuple_New(3); if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 917, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_5); __pyx_t_1 = 0; __pyx_t_4 = 127; __Pyx_INCREF(__pyx_kp_u_Out_of_bounds_on_buffer_access_a); __pyx_t_1 += 37; __Pyx_GIVEREF(__pyx_kp_u_Out_of_bounds_on_buffer_access_a); PyTuple_SET_ITEM(__pyx_t_5, 0, __pyx_kp_u_Out_of_bounds_on_buffer_access_a); __pyx_t_3 = __Pyx_PyUnicode_From_Py_ssize_t(__pyx_v_dim, 0, ' ', 'd'); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 917, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __pyx_t_1 += __Pyx_PyUnicode_GET_LENGTH(__pyx_t_3); __Pyx_GIVEREF(__pyx_t_3); PyTuple_SET_ITEM(__pyx_t_5, 1, __pyx_t_3); __pyx_t_3 = 0; __Pyx_INCREF(__pyx_kp_u__7); __pyx_t_1 += 1; __Pyx_GIVEREF(__pyx_kp_u__7); PyTuple_SET_ITEM(__pyx_t_5, 2, __pyx_kp_u__7); __pyx_t_3 = __Pyx_PyUnicode_Join(__pyx_t_5, 3, __pyx_t_1, __pyx_t_4); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 917, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; __Pyx_Raise(__pyx_builtin_IndexError, __pyx_t_3, 0, 0); __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; __PYX_ERR(1, 917, __pyx_L1_error) /* "View.MemoryView":916 * raise IndexError, f"Out of bounds on buffer access (axis {dim})" * * if index >= shape: # <<<<<<<<<<<<<< * raise IndexError, f"Out of bounds on buffer access (axis {dim})" * */ } /* "View.MemoryView":919 * raise IndexError, f"Out of bounds on buffer access (axis {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":920 * * resultp = bufp + index * stride * if suboffset >= 0: # <<<<<<<<<<<<<< * resultp = ( resultp)[0] + suboffset * */ __pyx_t_2 = (__pyx_v_suboffset >= 0); if (__pyx_t_2) { /* "View.MemoryView":921 * 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":920 * * resultp = bufp + index * stride * if suboffset >= 0: # <<<<<<<<<<<<<< * resultp = ( resultp)[0] + suboffset * */ } /* "View.MemoryView":923 * resultp = ( resultp)[0] + suboffset * * return resultp # <<<<<<<<<<<<<< * * */ __pyx_r = __pyx_v_resultp; goto __pyx_L0; /* "View.MemoryView":896 * * @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_5); __Pyx_AddTraceback("View.MemoryView.pybuffer_index", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __pyx_L0:; __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "View.MemoryView":929 * * @cname('__pyx_memslice_transpose') * cdef int transpose_memslice(__Pyx_memviewslice *memslice) except -1 nogil: # <<<<<<<<<<<<<< * 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; #ifdef WITH_THREAD PyGILState_STATE __pyx_gilstate_save; #endif /* "View.MemoryView":930 * @cname('__pyx_memslice_transpose') * cdef int transpose_memslice(__Pyx_memviewslice *memslice) except -1 nogil: * 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":932 * 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":933 * * 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":937 * * 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":938 * 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":939 * 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":940 * 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":942 * shape[i], shape[j] = shape[j], shape[i] * * if memslice.suboffsets[i] >= 0 or memslice.suboffsets[j] >= 0: # <<<<<<<<<<<<<< * _err(PyExc_ValueError, "Cannot transpose memoryview with indirect dimensions") * */ __pyx_t_8 = ((__pyx_v_memslice->suboffsets[__pyx_v_i]) >= 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); __pyx_t_7 = __pyx_t_8; __pyx_L6_bool_binop_done:; if (__pyx_t_7) { /* "View.MemoryView":943 * * if memslice.suboffsets[i] >= 0 or memslice.suboffsets[j] >= 0: * _err(PyExc_ValueError, "Cannot transpose memoryview with indirect dimensions") # <<<<<<<<<<<<<< * * return 0 */ __pyx_t_9 = __pyx_memoryview_err(PyExc_ValueError, __pyx_kp_s_Cannot_transpose_memoryview_with); if (unlikely(__pyx_t_9 == ((int)-1))) __PYX_ERR(1, 943, __pyx_L1_error) /* "View.MemoryView":942 * shape[i], shape[j] = shape[j], shape[i] * * if memslice.suboffsets[i] >= 0 or memslice.suboffsets[j] >= 0: # <<<<<<<<<<<<<< * _err(PyExc_ValueError, "Cannot transpose memoryview with indirect dimensions") * */ } } /* "View.MemoryView":945 * _err(PyExc_ValueError, "Cannot transpose memoryview with indirect dimensions") * * return 0 # <<<<<<<<<<<<<< * * */ __pyx_r = 0; goto __pyx_L0; /* "View.MemoryView":929 * * @cname('__pyx_memslice_transpose') * cdef int transpose_memslice(__Pyx_memviewslice *memslice) except -1 nogil: # <<<<<<<<<<<<<< * cdef int ndim = memslice.memview.view.ndim * */ /* function exit code */ __pyx_L1_error:; #ifdef WITH_THREAD __pyx_gilstate_save = __Pyx_PyGILState_Ensure(); #endif __Pyx_AddTraceback("View.MemoryView.transpose_memslice", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = -1; #ifdef WITH_THREAD __Pyx_PyGILState_Release(__pyx_gilstate_save); #endif __pyx_L0:; return __pyx_r; } /* "View.MemoryView":963 * cdef int (*to_dtype_func)(char *, object) except 0 * * def __dealloc__(self): # <<<<<<<<<<<<<< * __PYX_XCLEAR_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) { CYTHON_UNUSED PyObject *const *__pyx_kwvalues; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__dealloc__ (wrapper)", 0); __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs); __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) { /* "View.MemoryView":964 * * def __dealloc__(self): * __PYX_XCLEAR_MEMVIEW(&self.from_slice, 1) # <<<<<<<<<<<<<< * * cdef convert_item_to_object(self, char *itemp): */ __PYX_XCLEAR_MEMVIEW((&__pyx_v_self->from_slice), 1); /* "View.MemoryView":963 * cdef int (*to_dtype_func)(char *, object) except 0 * * def __dealloc__(self): # <<<<<<<<<<<<<< * __PYX_XCLEAR_MEMVIEW(&self.from_slice, 1) * */ /* function exit code */ } /* "View.MemoryView":966 * __PYX_XCLEAR_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", 1); /* "View.MemoryView":967 * * 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); if (__pyx_t_1) { /* "View.MemoryView":968 * 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, 968, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __pyx_r = __pyx_t_2; __pyx_t_2 = 0; goto __pyx_L0; /* "View.MemoryView":967 * * cdef convert_item_to_object(self, char *itemp): * if self.to_object_func != NULL: # <<<<<<<<<<<<<< * return self.to_object_func(itemp) * else: */ } /* "View.MemoryView":970 * 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, 970, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __pyx_r = __pyx_t_2; __pyx_t_2 = 0; goto __pyx_L0; } /* "View.MemoryView":966 * __PYX_XCLEAR_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":972 * 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", 1); /* "View.MemoryView":973 * * 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); if (__pyx_t_1) { /* "View.MemoryView":974 * 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, 974, __pyx_L1_error) /* "View.MemoryView":973 * * 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":976 * self.to_dtype_func(itemp, value) * else: * memoryview.assign_item_from_object(self, itemp, value) # <<<<<<<<<<<<<< * * cdef _get_base(self): */ /*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, 976, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; } __pyx_L3:; /* "View.MemoryView":972 * 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":978 * memoryview.assign_item_from_object(self, itemp, value) * * cdef _get_base(self): # <<<<<<<<<<<<<< * return self.from_object * */ static PyObject *__pyx_memoryviewslice__get_base(struct __pyx_memoryviewslice_obj *__pyx_v_self) { PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("_get_base", 1); /* "View.MemoryView":979 * * cdef _get_base(self): * return self.from_object # <<<<<<<<<<<<<< * * */ __Pyx_XDECREF(__pyx_r); __Pyx_INCREF(__pyx_v_self->from_object); __pyx_r = __pyx_v_self->from_object; goto __pyx_L0; /* "View.MemoryView":978 * memoryview.assign_item_from_object(self, itemp, value) * * cdef _get_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, #if CYTHON_METH_FASTCALL PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds #else PyObject *__pyx_args, PyObject *__pyx_kwds #endif ); /*proto*/ static PyObject *__pyx_pw___pyx_memoryviewslice_1__reduce_cython__(PyObject *__pyx_v_self, #if CYTHON_METH_FASTCALL PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds #else PyObject *__pyx_args, PyObject *__pyx_kwds #endif ) { #if !CYTHON_METH_FASTCALL CYTHON_UNUSED Py_ssize_t __pyx_nargs; #endif CYTHON_UNUSED PyObject *const *__pyx_kwvalues; PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__reduce_cython__ (wrapper)", 0); #if !CYTHON_METH_FASTCALL #if CYTHON_ASSUME_SAFE_MACROS __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); #else __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; #endif #endif __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); if (unlikely(__pyx_nargs > 0)) { __Pyx_RaiseArgtupleInvalid("__reduce_cython__", 1, 0, 0, __pyx_nargs); return NULL;} if (unlikely(__pyx_kwds) && __Pyx_NumKwargs_FASTCALL(__pyx_kwds) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "__reduce_cython__", 0))) return NULL; __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 int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("__reduce_cython__", 1); /* "(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_Raise(__pyx_builtin_TypeError, __pyx_kp_s_no_default___reduce___due_to_non, 0, 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_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, #if CYTHON_METH_FASTCALL PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds #else PyObject *__pyx_args, PyObject *__pyx_kwds #endif ); /*proto*/ static PyObject *__pyx_pw___pyx_memoryviewslice_3__setstate_cython__(PyObject *__pyx_v_self, #if CYTHON_METH_FASTCALL PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds #else PyObject *__pyx_args, PyObject *__pyx_kwds #endif ) { CYTHON_UNUSED PyObject *__pyx_v___pyx_state = 0; #if !CYTHON_METH_FASTCALL CYTHON_UNUSED Py_ssize_t __pyx_nargs; #endif CYTHON_UNUSED PyObject *const *__pyx_kwvalues; PyObject* values[1] = {0}; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__setstate_cython__ (wrapper)", 0); #if !CYTHON_METH_FASTCALL #if CYTHON_ASSUME_SAFE_MACROS __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); #else __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; #endif #endif __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); { PyObject **__pyx_pyargnames[] = {&__pyx_n_s_pyx_state,0}; if (__pyx_kwds) { Py_ssize_t kw_args; switch (__pyx_nargs) { case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); CYTHON_FALLTHROUGH; case 0: break; default: goto __pyx_L5_argtuple_error; } kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); switch (__pyx_nargs) { case 0: if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_pyx_state)) != 0)) { (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); kw_args--; } else if (unlikely(PyErr_Occurred())) __PYX_ERR(1, 3, __pyx_L3_error) else goto __pyx_L5_argtuple_error; } if (unlikely(kw_args > 0)) { const Py_ssize_t kwd_pos_args = __pyx_nargs; if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "__setstate_cython__") < 0)) __PYX_ERR(1, 3, __pyx_L3_error) } } else if (unlikely(__pyx_nargs != 1)) { goto __pyx_L5_argtuple_error; } else { values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); } __pyx_v___pyx_state = values[0]; } goto __pyx_L6_skip; __pyx_L5_argtuple_error:; __Pyx_RaiseArgtupleInvalid("__setstate_cython__", 1, 1, 1, __pyx_nargs); __PYX_ERR(1, 3, __pyx_L3_error) __pyx_L6_skip:; goto __pyx_L4_argument_unpacking_done; __pyx_L3_error:; { Py_ssize_t __pyx_temp; for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); } } __Pyx_AddTraceback("View.MemoryView._memoryviewslice.__setstate_cython__", __pyx_clineno, __pyx_lineno, __pyx_filename); __Pyx_RefNannyFinishContext(); return NULL; __pyx_L4_argument_unpacking_done:; __pyx_r = __pyx_pf___pyx_memoryviewslice_2__setstate_cython__(((struct __pyx_memoryviewslice_obj *)__pyx_v_self), __pyx_v___pyx_state); /* function exit code */ { Py_ssize_t __pyx_temp; for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); } } __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 int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("__setstate_cython__", 1); /* "(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_Raise(__pyx_builtin_TypeError, __pyx_kp_s_no_default___reduce___due_to_non, 0, 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_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":999 * * @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", 1); /* "View.MemoryView":1007 * cdef _memoryviewslice result * * if memviewslice.memview == Py_None: # <<<<<<<<<<<<<< * return None * */ __pyx_t_1 = (((PyObject *)__pyx_v_memviewslice.memview) == Py_None); if (__pyx_t_1) { /* "View.MemoryView":1008 * * if memviewslice.memview == Py_None: * return None # <<<<<<<<<<<<<< * * */ __Pyx_XDECREF(__pyx_r); __pyx_r = Py_None; __Pyx_INCREF(Py_None); goto __pyx_L0; /* "View.MemoryView":1007 * cdef _memoryviewslice result * * if memviewslice.memview == Py_None: # <<<<<<<<<<<<<< * return None * */ } /* "View.MemoryView":1013 * * * result = _memoryviewslice.__new__(_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, 1013, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __pyx_t_3 = PyTuple_New(3); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 1013, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __Pyx_INCREF(Py_None); __Pyx_GIVEREF(Py_None); if (__Pyx_PyTuple_SET_ITEM(__pyx_t_3, 0, Py_None)) __PYX_ERR(1, 1013, __pyx_L1_error); __Pyx_INCREF(__pyx_int_0); __Pyx_GIVEREF(__pyx_int_0); if (__Pyx_PyTuple_SET_ITEM(__pyx_t_3, 1, __pyx_int_0)) __PYX_ERR(1, 1013, __pyx_L1_error); __Pyx_GIVEREF(__pyx_t_2); if (__Pyx_PyTuple_SET_ITEM(__pyx_t_3, 2, __pyx_t_2)) __PYX_ERR(1, 1013, __pyx_L1_error); __pyx_t_2 = 0; __pyx_t_2 = ((PyObject *)__pyx_tp_new__memoryviewslice(((PyTypeObject *)__pyx_memoryviewslice_type), __pyx_t_3, NULL)); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 1013, __pyx_L1_error) __Pyx_GOTREF((PyObject *)__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":1015 * result = _memoryviewslice.__new__(_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":1016 * * result.from_slice = memviewslice * __PYX_INC_MEMVIEW(&memviewslice, 1) # <<<<<<<<<<<<<< * * result.from_object = ( memviewslice.memview)._get_base() */ __PYX_INC_MEMVIEW((&__pyx_v_memviewslice), 1); /* "View.MemoryView":1018 * __PYX_INC_MEMVIEW(&memviewslice, 1) * * result.from_object = ( memviewslice.memview)._get_base() # <<<<<<<<<<<<<< * result.typeinfo = memviewslice.memview.typeinfo * */ __pyx_t_2 = ((struct __pyx_vtabstruct_memoryview *)((struct __pyx_memoryview_obj *)__pyx_v_memviewslice.memview)->__pyx_vtab)->_get_base(((struct __pyx_memoryview_obj *)__pyx_v_memviewslice.memview)); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 1018, __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":1019 * * result.from_object = ( memviewslice.memview)._get_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":1021 * 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":1022 * * 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":1023 * 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":1024 * 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":1025 * 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":1027 * 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":1028 * * 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":1027 * Py_INCREF(Py_None) * * if (memviewslice.memview).flags & PyBUF_WRITABLE: # <<<<<<<<<<<<<< * result.flags = PyBUF_RECORDS * else: */ goto __pyx_L4; } /* "View.MemoryView":1030 * 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":1032 * 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":1033 * * 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":1036 * * * 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":1037 * * 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":1038 * 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); if (__pyx_t_1) { /* "View.MemoryView":1039 * 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":1040 * if suboffset >= 0: * result.view.suboffsets = result.from_slice.suboffsets * break # <<<<<<<<<<<<<< * * result.view.len = result.view.itemsize */ goto __pyx_L6_break; /* "View.MemoryView":1038 * 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":1042 * 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":1043 * * 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, 1043, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __Pyx_XDECREF_SET(__pyx_v_length, __pyx_t_2); __pyx_t_2 = 0; /* "View.MemoryView":1044 * 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, 1044, __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, 1044, __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, 1044, __pyx_L1_error) __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; __pyx_v_result->__pyx_base.view.len = __pyx_t_9; } /* "View.MemoryView":1046 * 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":1047 * * 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":1049 * 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":999 * * @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":1052 * * @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; PyObject *__pyx_t_2 = NULL; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("get_slice_from_memview", 1); /* "View.MemoryView":1055 * __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); if (__pyx_t_1) { /* "View.MemoryView":1056 * 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, 1056, __pyx_L1_error) __pyx_t_2 = ((PyObject *)__pyx_v_memview); __Pyx_INCREF(__pyx_t_2); __pyx_v_obj = ((struct __pyx_memoryviewslice_obj *)__pyx_t_2); __pyx_t_2 = 0; /* "View.MemoryView":1057 * 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":1055 * __Pyx_memviewslice *mslice) except NULL: * cdef _memoryviewslice obj * if isinstance(memview, _memoryviewslice): # <<<<<<<<<<<<<< * obj = memview * return &obj.from_slice */ } /* "View.MemoryView":1059 * return &obj.from_slice * else: * slice_copy(memview, mslice) # <<<<<<<<<<<<<< * return mslice * */ /*else*/ { __pyx_memoryview_slice_copy(__pyx_v_memview, __pyx_v_mslice); /* "View.MemoryView":1060 * else: * slice_copy(memview, mslice) * return mslice # <<<<<<<<<<<<<< * * @cname('__pyx_memoryview_slice_copy') */ __pyx_r = __pyx_v_mslice; goto __pyx_L0; } /* "View.MemoryView":1052 * * @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_2); __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":1063 * * @cname('__pyx_memoryview_slice_copy') * cdef void slice_copy(memoryview memview, __Pyx_memviewslice *dst) noexcept: # <<<<<<<<<<<<<< * 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; Py_ssize_t *__pyx_t_1; int __pyx_t_2; int __pyx_t_3; int __pyx_t_4; Py_ssize_t __pyx_t_5; int __pyx_t_6; /* "View.MemoryView":1067 * 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":1068 * * 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":1069 * 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":1071 * 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":1072 * * 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":1074 * 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":1075 * * 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":1076 * 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":1077 * dst.shape[dim] = shape[dim] * dst.strides[dim] = strides[dim] * dst.suboffsets[dim] = suboffsets[dim] if suboffsets else -1 # <<<<<<<<<<<<<< * * @cname('__pyx_memoryview_copy_object') */ __pyx_t_6 = (__pyx_v_suboffsets != 0); if (__pyx_t_6) { __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":1063 * * @cname('__pyx_memoryview_slice_copy') * cdef void slice_copy(memoryview memview, __Pyx_memviewslice *dst) noexcept: # <<<<<<<<<<<<<< * cdef int dim * cdef (Py_ssize_t*) shape, strides, suboffsets */ /* function exit code */ } /* "View.MemoryView":1080 * * @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", 1); /* "View.MemoryView":1083 * "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":1084 * 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, 1084, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_r = __pyx_t_1; __pyx_t_1 = 0; goto __pyx_L0; /* "View.MemoryView":1080 * * @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":1087 * * @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; PyObject *(*__pyx_t_2)(char *); int (*__pyx_t_3)(char *, PyObject *); PyObject *__pyx_t_4 = NULL; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("memoryview_copy_from_slice", 1); /* "View.MemoryView":1094 * 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); if (__pyx_t_1) { /* "View.MemoryView":1095 * * if isinstance(memview, _memoryviewslice): * to_object_func = (<_memoryviewslice> memview).to_object_func # <<<<<<<<<<<<<< * to_dtype_func = (<_memoryviewslice> memview).to_dtype_func * else: */ __pyx_t_2 = ((struct __pyx_memoryviewslice_obj *)__pyx_v_memview)->to_object_func; __pyx_v_to_object_func = __pyx_t_2; /* "View.MemoryView":1096 * 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_3 = ((struct __pyx_memoryviewslice_obj *)__pyx_v_memview)->to_dtype_func; __pyx_v_to_dtype_func = __pyx_t_3; /* "View.MemoryView":1094 * 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":1098 * 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":1099 * 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":1101 * 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":1103 * return memoryview_fromslice(memviewslice[0], memview.view.ndim, * to_object_func, to_dtype_func, * memview.dtype_is_object) # <<<<<<<<<<<<<< * * */ __pyx_t_4 = __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_4)) __PYX_ERR(1, 1101, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __pyx_r = __pyx_t_4; __pyx_t_4 = 0; goto __pyx_L0; /* "View.MemoryView":1087 * * @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_4); __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":1109 * * * cdef Py_ssize_t abs_py_ssize_t(Py_ssize_t arg) noexcept nogil: # <<<<<<<<<<<<<< * return -arg if arg < 0 else arg * */ static Py_ssize_t abs_py_ssize_t(Py_ssize_t __pyx_v_arg) { Py_ssize_t __pyx_r; Py_ssize_t __pyx_t_1; int __pyx_t_2; /* "View.MemoryView":1110 * * cdef Py_ssize_t abs_py_ssize_t(Py_ssize_t arg) noexcept nogil: * return -arg if arg < 0 else arg # <<<<<<<<<<<<<< * * @cname('__pyx_get_best_slice_order') */ __pyx_t_2 = (__pyx_v_arg < 0); if (__pyx_t_2) { __pyx_t_1 = (-__pyx_v_arg); } else { __pyx_t_1 = __pyx_v_arg; } __pyx_r = __pyx_t_1; goto __pyx_L0; /* "View.MemoryView":1109 * * * cdef Py_ssize_t abs_py_ssize_t(Py_ssize_t arg) noexcept nogil: # <<<<<<<<<<<<<< * return -arg if arg < 0 else arg * */ /* function exit code */ __pyx_L0:; return __pyx_r; } /* "View.MemoryView":1113 * * @cname('__pyx_get_best_slice_order') * cdef char get_best_order(__Pyx_memviewslice *mslice, int ndim) noexcept 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":1118 * """ * cdef int i * cdef Py_ssize_t c_stride = 0 # <<<<<<<<<<<<<< * cdef Py_ssize_t f_stride = 0 * */ __pyx_v_c_stride = 0; /* "View.MemoryView":1119 * 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":1121 * 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":1122 * * 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); if (__pyx_t_2) { /* "View.MemoryView":1123 * 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":1124 * if mslice.shape[i] > 1: * c_stride = mslice.strides[i] * break # <<<<<<<<<<<<<< * * for i in range(ndim): */ goto __pyx_L4_break; /* "View.MemoryView":1122 * * for i in range(ndim - 1, -1, -1): * if mslice.shape[i] > 1: # <<<<<<<<<<<<<< * c_stride = mslice.strides[i] * break */ } } __pyx_L4_break:; /* "View.MemoryView":1126 * 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":1127 * * 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); if (__pyx_t_2) { /* "View.MemoryView":1128 * 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":1129 * 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":1127 * * for i in range(ndim): * if mslice.shape[i] > 1: # <<<<<<<<<<<<<< * f_stride = mslice.strides[i] * break */ } } __pyx_L7_break:; /* "View.MemoryView":1131 * 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)); if (__pyx_t_2) { /* "View.MemoryView":1132 * * 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":1131 * break * * if abs_py_ssize_t(c_stride) <= abs_py_ssize_t(f_stride): # <<<<<<<<<<<<<< * return 'C' * else: */ } /* "View.MemoryView":1134 * return 'C' * else: * return 'F' # <<<<<<<<<<<<<< * * @cython.cdivision(True) */ /*else*/ { __pyx_r = 'F'; goto __pyx_L0; } /* "View.MemoryView":1113 * * @cname('__pyx_get_best_slice_order') * cdef char get_best_order(__Pyx_memviewslice *mslice, int ndim) noexcept nogil: # <<<<<<<<<<<<<< * """ * Figure out the best memory access order for a given slice. */ /* function exit code */ __pyx_L0:; return __pyx_r; } /* "View.MemoryView":1137 * * @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; Py_ssize_t __pyx_t_3; Py_ssize_t __pyx_t_4; Py_ssize_t __pyx_t_5; /* "View.MemoryView":1144 * * 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":1145 * 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":1146 * 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":1147 * 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":1149 * 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); if (__pyx_t_1) { /* "View.MemoryView":1150 * * 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); 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); if (__pyx_t_2) { } else { __pyx_t_1 = __pyx_t_2; goto __pyx_L5_bool_binop_done; } /* "View.MemoryView":1151 * 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_1 = __pyx_t_2; __pyx_L5_bool_binop_done:; /* "View.MemoryView":1150 * * 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":1152 * 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":1150 * * 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":1154 * 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_3 = __pyx_v_dst_extent; __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":1155 * 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":1156 * 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":1157 * 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":1149 * 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":1159 * 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_3 = __pyx_v_dst_extent; __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":1160 * 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":1164 * 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":1165 * 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":1137 * * @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":1167 * dst_data += dst_stride * * cdef void copy_strided_to_strided(__Pyx_memviewslice *src, # <<<<<<<<<<<<<< * __Pyx_memviewslice *dst, * int ndim, size_t itemsize) noexcept 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":1170 * __Pyx_memviewslice *dst, * int ndim, size_t itemsize) noexcept 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":1167 * dst_data += dst_stride * * cdef void copy_strided_to_strided(__Pyx_memviewslice *src, # <<<<<<<<<<<<<< * __Pyx_memviewslice *dst, * int ndim, size_t itemsize) noexcept nogil: */ /* function exit code */ } /* "View.MemoryView":1174 * * @cname('__pyx_memoryview_slice_get_size') * cdef Py_ssize_t slice_get_size(__Pyx_memviewslice *src, int ndim) noexcept 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":1176 * cdef Py_ssize_t slice_get_size(__Pyx_memviewslice *src, int ndim) noexcept 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":1178 * 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":1179 * * for shape in src.shape[:ndim]: * size *= shape # <<<<<<<<<<<<<< * * return size */ __pyx_v_size = (__pyx_v_size * __pyx_v_shape); } /* "View.MemoryView":1181 * size *= shape * * return size # <<<<<<<<<<<<<< * * @cname('__pyx_fill_contig_strides_array') */ __pyx_r = __pyx_v_size; goto __pyx_L0; /* "View.MemoryView":1174 * * @cname('__pyx_memoryview_slice_get_size') * cdef Py_ssize_t slice_get_size(__Pyx_memviewslice *src, int ndim) noexcept 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":1184 * * @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) noexcept 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":1193 * cdef int idx * * if order == 'F': # <<<<<<<<<<<<<< * for idx in range(ndim): * strides[idx] = stride */ __pyx_t_1 = (__pyx_v_order == 'F'); if (__pyx_t_1) { /* "View.MemoryView":1194 * * 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":1195 * 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":1196 * 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":1193 * cdef int idx * * if order == 'F': # <<<<<<<<<<<<<< * for idx in range(ndim): * strides[idx] = stride */ goto __pyx_L3; } /* "View.MemoryView":1198 * 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":1199 * 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":1200 * 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":1202 * stride *= shape[idx] * * return stride # <<<<<<<<<<<<<< * * @cname('__pyx_memoryview_copy_data_to_temp') */ __pyx_r = __pyx_v_stride; goto __pyx_L0; /* "View.MemoryView":1184 * * @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) noexcept nogil: */ /* function exit code */ __pyx_L0:; return __pyx_r; } /* "View.MemoryView":1205 * * @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; #ifdef WITH_THREAD PyGILState_STATE __pyx_gilstate_save; #endif /* "View.MemoryView":1216 * 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":1217 * * 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":1219 * cdef size_t size = slice_get_size(src, ndim) * * result = malloc(size) # <<<<<<<<<<<<<< * if not result: * _err_no_memory() */ __pyx_v_result = malloc(__pyx_v_size); /* "View.MemoryView":1220 * * result = malloc(size) * if not result: # <<<<<<<<<<<<<< * _err_no_memory() * */ __pyx_t_2 = (!(__pyx_v_result != 0)); if (__pyx_t_2) { /* "View.MemoryView":1221 * result = malloc(size) * if not result: * _err_no_memory() # <<<<<<<<<<<<<< * * */ __pyx_t_3 = __pyx_memoryview_err_no_memory(); if (unlikely(__pyx_t_3 == ((int)-1))) __PYX_ERR(1, 1221, __pyx_L1_error) /* "View.MemoryView":1220 * * result = malloc(size) * if not result: # <<<<<<<<<<<<<< * _err_no_memory() * */ } /* "View.MemoryView":1224 * * * tmpslice.data = result # <<<<<<<<<<<<<< * tmpslice.memview = src.memview * for i in range(ndim): */ __pyx_v_tmpslice->data = ((char *)__pyx_v_result); /* "View.MemoryView":1225 * * 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":1226 * 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":1227 * 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":1228 * 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, ndim, order) */ (__pyx_v_tmpslice->suboffsets[__pyx_v_i]) = -1L; } /* "View.MemoryView":1230 * 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":1233 * * * 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":1234 * * 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); if (__pyx_t_2) { /* "View.MemoryView":1235 * 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":1234 * * for i in range(ndim): * if tmpslice.shape[i] == 1: # <<<<<<<<<<<<<< * tmpslice.strides[i] = 0 * */ } } /* "View.MemoryView":1237 * 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); if (__pyx_t_2) { /* "View.MemoryView":1238 * * 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":1237 * tmpslice.strides[i] = 0 * * if slice_is_contig(src[0], order, ndim): # <<<<<<<<<<<<<< * memcpy(result, src.data, size) * else: */ goto __pyx_L9; } /* "View.MemoryView":1240 * 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":1242 * copy_strided_to_strided(src, tmpslice, ndim, itemsize) * * return result # <<<<<<<<<<<<<< * * */ __pyx_r = __pyx_v_result; goto __pyx_L0; /* "View.MemoryView":1205 * * @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 __pyx_gilstate_save = __Pyx_PyGILState_Ensure(); #endif __Pyx_AddTraceback("View.MemoryView.copy_data_to_temp", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; #ifdef WITH_THREAD __Pyx_PyGILState_Release(__pyx_gilstate_save); #endif __pyx_L0:; return __pyx_r; } /* "View.MemoryView":1247 * * @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, f"got differing extents in dimension {i} (got {extent1} and {extent2})" */ 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; Py_ssize_t __pyx_t_2; Py_UCS4 __pyx_t_3; 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":1249 * cdef int _err_extents(int i, Py_ssize_t extent1, * Py_ssize_t extent2) except -1 with gil: * raise ValueError, f"got differing extents in dimension {i} (got {extent1} and {extent2})" # <<<<<<<<<<<<<< * * @cname('__pyx_memoryview_err_dim') */ __pyx_t_1 = PyTuple_New(7); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 1249, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_t_2 = 0; __pyx_t_3 = 127; __Pyx_INCREF(__pyx_kp_u_got_differing_extents_in_dimensi); __pyx_t_2 += 35; __Pyx_GIVEREF(__pyx_kp_u_got_differing_extents_in_dimensi); PyTuple_SET_ITEM(__pyx_t_1, 0, __pyx_kp_u_got_differing_extents_in_dimensi); __pyx_t_4 = __Pyx_PyUnicode_From_int(__pyx_v_i, 0, ' ', 'd'); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 1249, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __pyx_t_2 += __Pyx_PyUnicode_GET_LENGTH(__pyx_t_4); __Pyx_GIVEREF(__pyx_t_4); PyTuple_SET_ITEM(__pyx_t_1, 1, __pyx_t_4); __pyx_t_4 = 0; __Pyx_INCREF(__pyx_kp_u_got); __pyx_t_2 += 6; __Pyx_GIVEREF(__pyx_kp_u_got); PyTuple_SET_ITEM(__pyx_t_1, 2, __pyx_kp_u_got); __pyx_t_4 = __Pyx_PyUnicode_From_Py_ssize_t(__pyx_v_extent1, 0, ' ', 'd'); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 1249, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __pyx_t_2 += __Pyx_PyUnicode_GET_LENGTH(__pyx_t_4); __Pyx_GIVEREF(__pyx_t_4); PyTuple_SET_ITEM(__pyx_t_1, 3, __pyx_t_4); __pyx_t_4 = 0; __Pyx_INCREF(__pyx_kp_u_and); __pyx_t_2 += 5; __Pyx_GIVEREF(__pyx_kp_u_and); PyTuple_SET_ITEM(__pyx_t_1, 4, __pyx_kp_u_and); __pyx_t_4 = __Pyx_PyUnicode_From_Py_ssize_t(__pyx_v_extent2, 0, ' ', 'd'); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 1249, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __pyx_t_2 += __Pyx_PyUnicode_GET_LENGTH(__pyx_t_4); __Pyx_GIVEREF(__pyx_t_4); PyTuple_SET_ITEM(__pyx_t_1, 5, __pyx_t_4); __pyx_t_4 = 0; __Pyx_INCREF(__pyx_kp_u__7); __pyx_t_2 += 1; __Pyx_GIVEREF(__pyx_kp_u__7); PyTuple_SET_ITEM(__pyx_t_1, 6, __pyx_kp_u__7); __pyx_t_4 = __Pyx_PyUnicode_Join(__pyx_t_1, 7, __pyx_t_2, __pyx_t_3); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 1249, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __Pyx_Raise(__pyx_builtin_ValueError, __pyx_t_4, 0, 0); __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __PYX_ERR(1, 1249, __pyx_L1_error) /* "View.MemoryView":1247 * * @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, f"got differing extents in dimension {i} (got {extent1} and {extent2})" */ /* function exit code */ __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_1); __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":1252 * * @cname('__pyx_memoryview_err_dim') * cdef int _err_dim(PyObject *error, str msg, int dim) except -1 with gil: # <<<<<<<<<<<<<< * raise error, msg % dim * */ static int __pyx_memoryview_err_dim(PyObject *__pyx_v_error, PyObject *__pyx_v_msg, int __pyx_v_dim) { int __pyx_r; __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; #ifdef WITH_THREAD PyGILState_STATE __pyx_gilstate_save = __Pyx_PyGILState_Ensure(); #endif __Pyx_RefNannySetupContext("_err_dim", 0); __Pyx_INCREF(__pyx_v_msg); /* "View.MemoryView":1253 * @cname('__pyx_memoryview_err_dim') * cdef int _err_dim(PyObject *error, str msg, int dim) except -1 with gil: * raise error, msg % dim # <<<<<<<<<<<<<< * * @cname('__pyx_memoryview_err') */ __pyx_t_1 = __Pyx_PyInt_From_int(__pyx_v_dim); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 1253, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_t_2 = __Pyx_PyString_FormatSafe(__pyx_v_msg, __pyx_t_1); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 1253, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __Pyx_Raise(((PyObject *)__pyx_v_error), __pyx_t_2, 0, 0); __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; __PYX_ERR(1, 1253, __pyx_L1_error) /* "View.MemoryView":1252 * * @cname('__pyx_memoryview_err_dim') * cdef int _err_dim(PyObject *error, str msg, int dim) except -1 with gil: # <<<<<<<<<<<<<< * raise error, msg % dim * */ /* function exit code */ __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_1); __Pyx_XDECREF(__pyx_t_2); __Pyx_AddTraceback("View.MemoryView._err_dim", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = -1; __Pyx_XDECREF(__pyx_v_msg); __Pyx_RefNannyFinishContext(); #ifdef WITH_THREAD __Pyx_PyGILState_Release(__pyx_gilstate_save); #endif return __pyx_r; } /* "View.MemoryView":1256 * * @cname('__pyx_memoryview_err') * cdef int _err(PyObject *error, str msg) except -1 with gil: # <<<<<<<<<<<<<< * raise error, msg * */ static int __pyx_memoryview_err(PyObject *__pyx_v_error, PyObject *__pyx_v_msg) { int __pyx_r; __Pyx_RefNannyDeclarations 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_msg); /* "View.MemoryView":1257 * @cname('__pyx_memoryview_err') * cdef int _err(PyObject *error, str msg) except -1 with gil: * raise error, msg # <<<<<<<<<<<<<< * * @cname('__pyx_memoryview_err_no_memory') */ __Pyx_Raise(((PyObject *)__pyx_v_error), __pyx_v_msg, 0, 0); __PYX_ERR(1, 1257, __pyx_L1_error) /* "View.MemoryView":1256 * * @cname('__pyx_memoryview_err') * cdef int _err(PyObject *error, str msg) except -1 with gil: # <<<<<<<<<<<<<< * raise error, msg * */ /* function exit code */ __pyx_L1_error:; __Pyx_AddTraceback("View.MemoryView._err", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = -1; __Pyx_XDECREF(__pyx_v_msg); __Pyx_RefNannyFinishContext(); #ifdef WITH_THREAD __Pyx_PyGILState_Release(__pyx_gilstate_save); #endif return __pyx_r; } /* "View.MemoryView":1260 * * @cname('__pyx_memoryview_err_no_memory') * cdef int _err_no_memory() except -1 with gil: # <<<<<<<<<<<<<< * raise MemoryError * */ static int __pyx_memoryview_err_no_memory(void) { int __pyx_r; 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 /* "View.MemoryView":1261 * @cname('__pyx_memoryview_err_no_memory') * cdef int _err_no_memory() except -1 with gil: * raise MemoryError # <<<<<<<<<<<<<< * * */ PyErr_NoMemory(); __PYX_ERR(1, 1261, __pyx_L1_error) /* "View.MemoryView":1260 * * @cname('__pyx_memoryview_err_no_memory') * cdef int _err_no_memory() except -1 with gil: # <<<<<<<<<<<<<< * raise MemoryError * */ /* function exit code */ __pyx_L1_error:; __Pyx_AddTraceback("View.MemoryView._err_no_memory", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = -1; #ifdef WITH_THREAD __Pyx_PyGILState_Release(__pyx_gilstate_save); #endif return __pyx_r; } /* "View.MemoryView":1265 * * @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_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; #ifdef WITH_THREAD PyGILState_STATE __pyx_gilstate_save; #endif /* "View.MemoryView":1273 * 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":1274 * """ * 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":1276 * 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":1277 * 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":1278 * 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":1281 * 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); if (__pyx_t_2) { /* "View.MemoryView":1282 * * 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":1281 * 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":1283 * 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); if (__pyx_t_2) { /* "View.MemoryView":1284 * 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":1283 * 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":1286 * 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; __pyx_t_2 = (__pyx_t_3 > __pyx_t_4); if (__pyx_t_2) { __pyx_t_5 = __pyx_t_3; } else { __pyx_t_5 = __pyx_t_4; } __pyx_v_ndim = __pyx_t_5; /* "View.MemoryView":1288 * 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":1289 * * 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])); if (__pyx_t_2) { /* "View.MemoryView":1290 * 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); if (__pyx_t_2) { /* "View.MemoryView":1291 * 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":1292 * 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":1290 * 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":1294 * 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, 1294, __pyx_L1_error) } __pyx_L7:; /* "View.MemoryView":1289 * * for i in range(ndim): * if src.shape[i] != dst.shape[i]: # <<<<<<<<<<<<<< * if src.shape[i] == 1: * broadcasting = True */ } /* "View.MemoryView":1296 * _err_extents(i, dst.shape[i], src.shape[i]) * * if src.suboffsets[i] >= 0: # <<<<<<<<<<<<<< * _err_dim(PyExc_ValueError, "Dimension %d is not direct", i) * */ __pyx_t_2 = ((__pyx_v_src.suboffsets[__pyx_v_i]) >= 0); if (__pyx_t_2) { /* "View.MemoryView":1297 * * if src.suboffsets[i] >= 0: * _err_dim(PyExc_ValueError, "Dimension %d is not direct", i) # <<<<<<<<<<<<<< * * if slices_overlap(&src, &dst, ndim, itemsize): */ __pyx_t_6 = __pyx_memoryview_err_dim(PyExc_ValueError, __pyx_kp_s_Dimension_d_is_not_direct, __pyx_v_i); if (unlikely(__pyx_t_6 == ((int)-1))) __PYX_ERR(1, 1297, __pyx_L1_error) /* "View.MemoryView":1296 * _err_extents(i, dst.shape[i], src.shape[i]) * * if src.suboffsets[i] >= 0: # <<<<<<<<<<<<<< * _err_dim(PyExc_ValueError, "Dimension %d is not direct", i) * */ } } /* "View.MemoryView":1299 * _err_dim(PyExc_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); if (__pyx_t_2) { /* "View.MemoryView":1301 * 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)); if (__pyx_t_2) { /* "View.MemoryView":1302 * * 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":1301 * if slices_overlap(&src, &dst, ndim, itemsize): * * if not slice_is_contig(src, order, ndim): # <<<<<<<<<<<<<< * order = get_best_order(&dst, ndim) * */ } /* "View.MemoryView":1304 * 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, 1304, __pyx_L1_error) __pyx_v_tmpdata = __pyx_t_7; /* "View.MemoryView":1305 * * tmpdata = copy_data_to_temp(&src, &tmp, order, ndim) * src = tmp # <<<<<<<<<<<<<< * * if not broadcasting: */ __pyx_v_src = __pyx_v_tmp; /* "View.MemoryView":1299 * _err_dim(PyExc_ValueError, "Dimension %d is not direct", i) * * if slices_overlap(&src, &dst, ndim, itemsize): # <<<<<<<<<<<<<< * * if not slice_is_contig(src, order, ndim): */ } /* "View.MemoryView":1307 * src = tmp * * if not broadcasting: # <<<<<<<<<<<<<< * * */ __pyx_t_2 = (!__pyx_v_broadcasting); if (__pyx_t_2) { /* "View.MemoryView":1310 * * * 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); if (__pyx_t_2) { /* "View.MemoryView":1311 * * 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":1310 * * * 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":1312 * 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); if (__pyx_t_2) { /* "View.MemoryView":1313 * 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":1312 * 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":1315 * direct_copy = slice_is_contig(dst, 'F', ndim) * * if direct_copy: # <<<<<<<<<<<<<< * * refcount_copying(&dst, dtype_is_object, ndim, inc=False) */ if (__pyx_v_direct_copy) { /* "View.MemoryView":1317 * if direct_copy: * * refcount_copying(&dst, dtype_is_object, ndim, inc=False) # <<<<<<<<<<<<<< * memcpy(dst.data, src.data, slice_get_size(&src, ndim)) * refcount_copying(&dst, dtype_is_object, ndim, inc=True) */ __pyx_memoryview_refcount_copying((&__pyx_v_dst), __pyx_v_dtype_is_object, __pyx_v_ndim, 0); /* "View.MemoryView":1318 * * refcount_copying(&dst, dtype_is_object, ndim, inc=False) * memcpy(dst.data, src.data, slice_get_size(&src, ndim)) # <<<<<<<<<<<<<< * refcount_copying(&dst, dtype_is_object, ndim, inc=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":1319 * refcount_copying(&dst, dtype_is_object, ndim, inc=False) * memcpy(dst.data, src.data, slice_get_size(&src, ndim)) * refcount_copying(&dst, dtype_is_object, ndim, inc=True) # <<<<<<<<<<<<<< * free(tmpdata) * return 0 */ __pyx_memoryview_refcount_copying((&__pyx_v_dst), __pyx_v_dtype_is_object, __pyx_v_ndim, 1); /* "View.MemoryView":1320 * memcpy(dst.data, src.data, slice_get_size(&src, ndim)) * refcount_copying(&dst, dtype_is_object, ndim, inc=True) * free(tmpdata) # <<<<<<<<<<<<<< * return 0 * */ free(__pyx_v_tmpdata); /* "View.MemoryView":1321 * refcount_copying(&dst, dtype_is_object, ndim, inc=True) * free(tmpdata) * return 0 # <<<<<<<<<<<<<< * * if order == 'F' == get_best_order(&dst, ndim): */ __pyx_r = 0; goto __pyx_L0; /* "View.MemoryView":1315 * direct_copy = slice_is_contig(dst, 'F', ndim) * * if direct_copy: # <<<<<<<<<<<<<< * * refcount_copying(&dst, dtype_is_object, ndim, inc=False) */ } /* "View.MemoryView":1307 * src = tmp * * if not broadcasting: # <<<<<<<<<<<<<< * * */ } /* "View.MemoryView":1323 * 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)); } if (__pyx_t_2) { /* "View.MemoryView":1326 * * * transpose_memslice(&src) # <<<<<<<<<<<<<< * transpose_memslice(&dst) * */ __pyx_t_5 = __pyx_memslice_transpose((&__pyx_v_src)); if (unlikely(__pyx_t_5 == ((int)-1))) __PYX_ERR(1, 1326, __pyx_L1_error) /* "View.MemoryView":1327 * * transpose_memslice(&src) * transpose_memslice(&dst) # <<<<<<<<<<<<<< * * refcount_copying(&dst, dtype_is_object, ndim, inc=False) */ __pyx_t_5 = __pyx_memslice_transpose((&__pyx_v_dst)); if (unlikely(__pyx_t_5 == ((int)-1))) __PYX_ERR(1, 1327, __pyx_L1_error) /* "View.MemoryView":1323 * return 0 * * if order == 'F' == get_best_order(&dst, ndim): # <<<<<<<<<<<<<< * * */ } /* "View.MemoryView":1329 * transpose_memslice(&dst) * * refcount_copying(&dst, dtype_is_object, ndim, inc=False) # <<<<<<<<<<<<<< * copy_strided_to_strided(&src, &dst, ndim, itemsize) * refcount_copying(&dst, dtype_is_object, ndim, inc=True) */ __pyx_memoryview_refcount_copying((&__pyx_v_dst), __pyx_v_dtype_is_object, __pyx_v_ndim, 0); /* "View.MemoryView":1330 * * refcount_copying(&dst, dtype_is_object, ndim, inc=False) * copy_strided_to_strided(&src, &dst, ndim, itemsize) # <<<<<<<<<<<<<< * refcount_copying(&dst, dtype_is_object, ndim, inc=True) * */ copy_strided_to_strided((&__pyx_v_src), (&__pyx_v_dst), __pyx_v_ndim, __pyx_v_itemsize); /* "View.MemoryView":1331 * refcount_copying(&dst, dtype_is_object, ndim, inc=False) * copy_strided_to_strided(&src, &dst, ndim, itemsize) * refcount_copying(&dst, dtype_is_object, ndim, inc=True) # <<<<<<<<<<<<<< * * free(tmpdata) */ __pyx_memoryview_refcount_copying((&__pyx_v_dst), __pyx_v_dtype_is_object, __pyx_v_ndim, 1); /* "View.MemoryView":1333 * refcount_copying(&dst, dtype_is_object, ndim, inc=True) * * free(tmpdata) # <<<<<<<<<<<<<< * return 0 * */ free(__pyx_v_tmpdata); /* "View.MemoryView":1334 * * free(tmpdata) * return 0 # <<<<<<<<<<<<<< * * @cname('__pyx_memoryview_broadcast_leading') */ __pyx_r = 0; goto __pyx_L0; /* "View.MemoryView":1265 * * @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 __pyx_gilstate_save = __Pyx_PyGILState_Ensure(); #endif __Pyx_AddTraceback("View.MemoryView.memoryview_copy_contents", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = -1; #ifdef WITH_THREAD __Pyx_PyGILState_Release(__pyx_gilstate_save); #endif __pyx_L0:; return __pyx_r; } /* "View.MemoryView":1337 * * @cname('__pyx_memoryview_broadcast_leading') * cdef void broadcast_leading(__Pyx_memviewslice *mslice, # <<<<<<<<<<<<<< * int ndim, * int ndim_other) noexcept 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":1341 * int ndim_other) noexcept 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":1343 * 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":1344 * * 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":1345 * 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":1346 * 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":1348 * 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":1349 * * 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":1350 * 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":1351 * mslice.shape[i] = 1 * mslice.strides[i] = mslice.strides[0] * mslice.suboffsets[i] = -1 # <<<<<<<<<<<<<< * * */ (__pyx_v_mslice->suboffsets[__pyx_v_i]) = -1L; } /* "View.MemoryView":1337 * * @cname('__pyx_memoryview_broadcast_leading') * cdef void broadcast_leading(__Pyx_memviewslice *mslice, # <<<<<<<<<<<<<< * int ndim, * int ndim_other) noexcept nogil: */ /* function exit code */ } /* "View.MemoryView":1359 * * @cname('__pyx_memoryview_refcount_copying') * cdef void refcount_copying(__Pyx_memviewslice *dst, bint dtype_is_object, int ndim, bint inc) noexcept nogil: # <<<<<<<<<<<<<< * * if dtype_is_object: */ 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) { /* "View.MemoryView":1361 * cdef void refcount_copying(__Pyx_memviewslice *dst, bint dtype_is_object, int ndim, bint inc) noexcept nogil: * * if dtype_is_object: # <<<<<<<<<<<<<< * refcount_objects_in_slice_with_gil(dst.data, dst.shape, dst.strides, ndim, inc) * */ if (__pyx_v_dtype_is_object) { /* "View.MemoryView":1362 * * if dtype_is_object: * refcount_objects_in_slice_with_gil(dst.data, dst.shape, dst.strides, ndim, inc) # <<<<<<<<<<<<<< * * @cname('__pyx_memoryview_refcount_objects_in_slice_with_gil') */ __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":1361 * cdef void refcount_copying(__Pyx_memviewslice *dst, bint dtype_is_object, int ndim, bint inc) noexcept nogil: * * if dtype_is_object: # <<<<<<<<<<<<<< * refcount_objects_in_slice_with_gil(dst.data, dst.shape, dst.strides, ndim, inc) * */ } /* "View.MemoryView":1359 * * @cname('__pyx_memoryview_refcount_copying') * cdef void refcount_copying(__Pyx_memviewslice *dst, bint dtype_is_object, int ndim, bint inc) noexcept nogil: # <<<<<<<<<<<<<< * * if dtype_is_object: */ /* function exit code */ } /* "View.MemoryView":1365 * * @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) noexcept 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) { #ifdef WITH_THREAD PyGILState_STATE __pyx_gilstate_save = __Pyx_PyGILState_Ensure(); #endif /* "View.MemoryView":1368 * Py_ssize_t *strides, int ndim, * bint inc) noexcept 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":1365 * * @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) noexcept with gil: */ /* function exit code */ #ifdef WITH_THREAD __Pyx_PyGILState_Release(__pyx_gilstate_save); #endif } /* "View.MemoryView":1371 * * @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) noexcept: * 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; Py_ssize_t __pyx_v_stride; Py_ssize_t __pyx_t_1; Py_ssize_t __pyx_t_2; Py_ssize_t __pyx_t_3; int __pyx_t_4; /* "View.MemoryView":1374 * Py_ssize_t *strides, int ndim, bint inc) noexcept: * cdef Py_ssize_t i * cdef Py_ssize_t stride = strides[0] # <<<<<<<<<<<<<< * * for i in range(shape[0]): */ __pyx_v_stride = (__pyx_v_strides[0]); /* "View.MemoryView":1376 * cdef Py_ssize_t stride = strides[0] * * 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":1377 * * for i in range(shape[0]): * if ndim == 1: # <<<<<<<<<<<<<< * if inc: * Py_INCREF(( data)[0]) */ __pyx_t_4 = (__pyx_v_ndim == 1); if (__pyx_t_4) { /* "View.MemoryView":1378 * for i in range(shape[0]): * if ndim == 1: * if inc: # <<<<<<<<<<<<<< * Py_INCREF(( data)[0]) * else: */ if (__pyx_v_inc) { /* "View.MemoryView":1379 * if ndim == 1: * if inc: * Py_INCREF(( data)[0]) # <<<<<<<<<<<<<< * else: * Py_DECREF(( data)[0]) */ Py_INCREF((((PyObject **)__pyx_v_data)[0])); /* "View.MemoryView":1378 * for i in range(shape[0]): * if ndim == 1: * if inc: # <<<<<<<<<<<<<< * Py_INCREF(( data)[0]) * else: */ goto __pyx_L6; } /* "View.MemoryView":1381 * Py_INCREF(( data)[0]) * else: * Py_DECREF(( data)[0]) # <<<<<<<<<<<<<< * else: * refcount_objects_in_slice(data, shape + 1, strides + 1, ndim - 1, inc) */ /*else*/ { Py_DECREF((((PyObject **)__pyx_v_data)[0])); } __pyx_L6:; /* "View.MemoryView":1377 * * for i in range(shape[0]): * if ndim == 1: # <<<<<<<<<<<<<< * if inc: * Py_INCREF(( data)[0]) */ goto __pyx_L5; } /* "View.MemoryView":1383 * Py_DECREF(( data)[0]) * else: * refcount_objects_in_slice(data, shape + 1, strides + 1, ndim - 1, inc) # <<<<<<<<<<<<<< * * data += stride */ /*else*/ { __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":1385 * refcount_objects_in_slice(data, shape + 1, strides + 1, ndim - 1, inc) * * data += stride # <<<<<<<<<<<<<< * * */ __pyx_v_data = (__pyx_v_data + __pyx_v_stride); } /* "View.MemoryView":1371 * * @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) noexcept: * cdef Py_ssize_t i */ /* function exit code */ } /* "View.MemoryView":1391 * * @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) noexcept 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":1394 * size_t itemsize, void *item, * bint dtype_is_object) noexcept nogil: * refcount_copying(dst, dtype_is_object, ndim, inc=False) # <<<<<<<<<<<<<< * _slice_assign_scalar(dst.data, dst.shape, dst.strides, ndim, itemsize, item) * refcount_copying(dst, dtype_is_object, ndim, inc=True) */ __pyx_memoryview_refcount_copying(__pyx_v_dst, __pyx_v_dtype_is_object, __pyx_v_ndim, 0); /* "View.MemoryView":1395 * bint dtype_is_object) noexcept nogil: * refcount_copying(dst, dtype_is_object, ndim, inc=False) * _slice_assign_scalar(dst.data, dst.shape, dst.strides, ndim, itemsize, item) # <<<<<<<<<<<<<< * refcount_copying(dst, dtype_is_object, ndim, inc=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":1396 * refcount_copying(dst, dtype_is_object, ndim, inc=False) * _slice_assign_scalar(dst.data, dst.shape, dst.strides, ndim, itemsize, item) * refcount_copying(dst, dtype_is_object, ndim, inc=True) # <<<<<<<<<<<<<< * * */ __pyx_memoryview_refcount_copying(__pyx_v_dst, __pyx_v_dtype_is_object, __pyx_v_ndim, 1); /* "View.MemoryView":1391 * * @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) noexcept nogil: */ /* function exit code */ } /* "View.MemoryView":1400 * * @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) noexcept 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":1404 * size_t itemsize, void *item) noexcept 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":1405 * 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":1407 * 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); if (__pyx_t_1) { /* "View.MemoryView":1408 * * 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":1409 * 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":1410 * 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":1407 * cdef Py_ssize_t extent = shape[0] * * if ndim == 1: # <<<<<<<<<<<<<< * for i in range(extent): * memcpy(data, item, itemsize) */ goto __pyx_L3; } /* "View.MemoryView":1412 * data += stride * else: * for i in range(extent): # <<<<<<<<<<<<<< * _slice_assign_scalar(data, shape + 1, strides + 1, ndim - 1, itemsize, item) * data += stride */ /*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":1413 * 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":1414 * for i in range(extent): * _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":1400 * * @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) noexcept 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, #if CYTHON_METH_FASTCALL PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds #else PyObject *__pyx_args, PyObject *__pyx_kwds #endif ); /*proto*/ static PyMethodDef __pyx_mdef_15View_dot_MemoryView_1__pyx_unpickle_Enum = {"__pyx_unpickle_Enum", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_15View_dot_MemoryView_1__pyx_unpickle_Enum, __Pyx_METH_FASTCALL|METH_KEYWORDS, 0}; static PyObject *__pyx_pw_15View_dot_MemoryView_1__pyx_unpickle_Enum(PyObject *__pyx_self, #if CYTHON_METH_FASTCALL PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds #else PyObject *__pyx_args, PyObject *__pyx_kwds #endif ) { PyObject *__pyx_v___pyx_type = 0; long __pyx_v___pyx_checksum; PyObject *__pyx_v___pyx_state = 0; #if !CYTHON_METH_FASTCALL CYTHON_UNUSED Py_ssize_t __pyx_nargs; #endif CYTHON_UNUSED PyObject *const *__pyx_kwvalues; PyObject* values[3] = {0,0,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); #if !CYTHON_METH_FASTCALL #if CYTHON_ASSUME_SAFE_MACROS __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); #else __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; #endif #endif __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); { PyObject **__pyx_pyargnames[] = {&__pyx_n_s_pyx_type,&__pyx_n_s_pyx_checksum,&__pyx_n_s_pyx_state,0}; if (__pyx_kwds) { Py_ssize_t kw_args; switch (__pyx_nargs) { case 3: values[2] = __Pyx_Arg_FASTCALL(__pyx_args, 2); CYTHON_FALLTHROUGH; case 2: values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); CYTHON_FALLTHROUGH; case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); CYTHON_FALLTHROUGH; case 0: break; default: goto __pyx_L5_argtuple_error; } kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); switch (__pyx_nargs) { case 0: if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_pyx_type)) != 0)) { (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); kw_args--; } else if (unlikely(PyErr_Occurred())) __PYX_ERR(1, 1, __pyx_L3_error) else goto __pyx_L5_argtuple_error; CYTHON_FALLTHROUGH; case 1: if (likely((values[1] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_pyx_checksum)) != 0)) { (void)__Pyx_Arg_NewRef_FASTCALL(values[1]); kw_args--; } else if (unlikely(PyErr_Occurred())) __PYX_ERR(1, 1, __pyx_L3_error) 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_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_pyx_state)) != 0)) { (void)__Pyx_Arg_NewRef_FASTCALL(values[2]); kw_args--; } else if (unlikely(PyErr_Occurred())) __PYX_ERR(1, 1, __pyx_L3_error) else { __Pyx_RaiseArgtupleInvalid("__pyx_unpickle_Enum", 1, 3, 3, 2); __PYX_ERR(1, 1, __pyx_L3_error) } } if (unlikely(kw_args > 0)) { const Py_ssize_t kwd_pos_args = __pyx_nargs; if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "__pyx_unpickle_Enum") < 0)) __PYX_ERR(1, 1, __pyx_L3_error) } } else if (unlikely(__pyx_nargs != 3)) { goto __pyx_L5_argtuple_error; } else { values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); values[2] = __Pyx_Arg_FASTCALL(__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_L6_skip; __pyx_L5_argtuple_error:; __Pyx_RaiseArgtupleInvalid("__pyx_unpickle_Enum", 1, 3, 3, __pyx_nargs); __PYX_ERR(1, 1, __pyx_L3_error) __pyx_L6_skip:; goto __pyx_L4_argument_unpacking_done; __pyx_L3_error:; { Py_ssize_t __pyx_temp; for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); } } __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 */ { Py_ssize_t __pyx_temp; for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); } } __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; PyObject *__pyx_t_3 = NULL; PyObject *__pyx_t_4 = NULL; int __pyx_t_5; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("__pyx_unpickle_Enum", 1); /* "(tree fragment)":4 * cdef object __pyx_PickleError * cdef object __pyx_result * if __pyx_checksum not in (0x82a3537, 0x6ae9995, 0xb068931): # <<<<<<<<<<<<<< * from pickle import PickleError as __pyx_PickleError * raise __pyx_PickleError, "Incompatible checksums (0x%x vs (0x82a3537, 0x6ae9995, 0xb068931) = (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__8, Py_NE)); if (unlikely((__pyx_t_2 < 0))) __PYX_ERR(1, 4, __pyx_L1_error) __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; if (__pyx_t_2) { /* "(tree fragment)":5 * cdef object __pyx_result * if __pyx_checksum not in (0x82a3537, 0x6ae9995, 0xb068931): * from pickle import PickleError as __pyx_PickleError # <<<<<<<<<<<<<< * raise __pyx_PickleError, "Incompatible checksums (0x%x vs (0x82a3537, 0x6ae9995, 0xb068931) = (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); if (__Pyx_PyList_SET_ITEM(__pyx_t_1, 0, __pyx_n_s_PickleError)) __PYX_ERR(1, 5, __pyx_L1_error); __pyx_t_3 = __Pyx_Import(__pyx_n_s_pickle, __pyx_t_1, 0); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 5, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __pyx_t_1 = __Pyx_ImportFrom(__pyx_t_3, __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_3); __pyx_t_3 = 0; /* "(tree fragment)":6 * if __pyx_checksum not in (0x82a3537, 0x6ae9995, 0xb068931): * from pickle import PickleError as __pyx_PickleError * raise __pyx_PickleError, "Incompatible checksums (0x%x vs (0x82a3537, 0x6ae9995, 0xb068931) = (name))" % __pyx_checksum # <<<<<<<<<<<<<< * __pyx_result = Enum.__new__(__pyx_type) * if __pyx_state is not None: */ __pyx_t_3 = __Pyx_PyInt_From_long(__pyx_v___pyx_checksum); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 6, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __pyx_t_1 = __Pyx_PyString_Format(__pyx_kp_s_Incompatible_checksums_0x_x_vs_0, __pyx_t_3); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 6, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; __Pyx_Raise(__pyx_v___pyx_PickleError, __pyx_t_1, 0, 0); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __PYX_ERR(1, 6, __pyx_L1_error) /* "(tree fragment)":4 * cdef object __pyx_PickleError * cdef object __pyx_result * if __pyx_checksum not in (0x82a3537, 0x6ae9995, 0xb068931): # <<<<<<<<<<<<<< * from pickle import PickleError as __pyx_PickleError * raise __pyx_PickleError, "Incompatible checksums (0x%x vs (0x82a3537, 0x6ae9995, 0xb068931) = (name))" % __pyx_checksum */ } /* "(tree fragment)":7 * from pickle import PickleError as __pyx_PickleError * raise __pyx_PickleError, "Incompatible checksums (0x%x vs (0x82a3537, 0x6ae9995, 0xb068931) = (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_3 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_MemviewEnum_type), __pyx_n_s_new); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 7, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __pyx_t_4 = NULL; __pyx_t_5 = 0; #if CYTHON_UNPACK_METHODS if (likely(PyMethod_Check(__pyx_t_3))) { __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_3); if (likely(__pyx_t_4)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3); __Pyx_INCREF(__pyx_t_4); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_3, function); __pyx_t_5 = 1; } } #endif { PyObject *__pyx_callargs[2] = {__pyx_t_4, __pyx_v___pyx_type}; __pyx_t_1 = __Pyx_PyObject_FastCall(__pyx_t_3, __pyx_callargs+1-__pyx_t_5, 1+__pyx_t_5); __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 7, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; } __pyx_v___pyx_result = __pyx_t_1; __pyx_t_1 = 0; /* "(tree fragment)":8 * raise __pyx_PickleError, "Incompatible checksums (0x%x vs (0x82a3537, 0x6ae9995, 0xb068931) = (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_2 = (__pyx_v___pyx_state != Py_None); 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) || __Pyx_RaiseUnexpectedTypeError("tuple", __pyx_v___pyx_state))) __PYX_ERR(1, 9, __pyx_L1_error) __pyx_t_1 = __pyx_unpickle_Enum__set_state(((struct __pyx_MemviewEnum_obj *)__pyx_v___pyx_result), ((PyObject*)__pyx_v___pyx_state)); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 9, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; /* "(tree fragment)":8 * raise __pyx_PickleError, "Incompatible checksums (0x%x vs (0x82a3537, 0x6ae9995, 0xb068931) = (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_3); __Pyx_XDECREF(__pyx_t_4); __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; PyObject *__pyx_t_5 = NULL; PyObject *__pyx_t_6 = NULL; PyObject *__pyx_t_7 = NULL; int __pyx_t_8; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("__pyx_unpickle_Enum__set_state", 1); /* "(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 = __Pyx_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); 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_2 = __pyx_t_4; __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_5 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v___pyx_result), __pyx_n_s_dict); if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 14, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_5); __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_t_5, __pyx_n_s_update); if (unlikely(!__pyx_t_6)) __PYX_ERR(1, 14, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 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_5 = __Pyx_GetItemInt_Tuple(__pyx_v___pyx_state, 1, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 14, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_5); __pyx_t_7 = NULL; __pyx_t_8 = 0; #if CYTHON_UNPACK_METHODS if (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_8 = 1; } } #endif { PyObject *__pyx_callargs[2] = {__pyx_t_7, __pyx_t_5}; __pyx_t_1 = __Pyx_PyObject_FastCall(__pyx_t_6, __pyx_callargs+1-__pyx_t_8, 1+__pyx_t_8); __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 14, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 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_5); __Pyx_XDECREF(__pyx_t_6); __Pyx_XDECREF(__pyx_t_7); __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; } /* "../../../../../tmp/build-env-2vlxkjf_/lib/python3.12/site-packages/numpy/__init__.cython-30.pxd":286 * * @property * cdef inline npy_intp itemsize(self) noexcept nogil: # <<<<<<<<<<<<<< * return PyDataType_ELSIZE(self) * */ static CYTHON_INLINE npy_intp __pyx_f_5numpy_5dtype_8itemsize_itemsize(PyArray_Descr *__pyx_v_self) { npy_intp __pyx_r; /* "../../../../../tmp/build-env-2vlxkjf_/lib/python3.12/site-packages/numpy/__init__.cython-30.pxd":287 * @property * cdef inline npy_intp itemsize(self) noexcept nogil: * return PyDataType_ELSIZE(self) # <<<<<<<<<<<<<< * * @property */ __pyx_r = PyDataType_ELSIZE(__pyx_v_self); goto __pyx_L0; /* "../../../../../tmp/build-env-2vlxkjf_/lib/python3.12/site-packages/numpy/__init__.cython-30.pxd":286 * * @property * cdef inline npy_intp itemsize(self) noexcept nogil: # <<<<<<<<<<<<<< * return PyDataType_ELSIZE(self) * */ /* function exit code */ __pyx_L0:; return __pyx_r; } /* "../../../../../tmp/build-env-2vlxkjf_/lib/python3.12/site-packages/numpy/__init__.cython-30.pxd":290 * * @property * cdef inline npy_intp alignment(self) noexcept nogil: # <<<<<<<<<<<<<< * return PyDataType_ALIGNMENT(self) * */ static CYTHON_INLINE npy_intp __pyx_f_5numpy_5dtype_9alignment_alignment(PyArray_Descr *__pyx_v_self) { npy_intp __pyx_r; /* "../../../../../tmp/build-env-2vlxkjf_/lib/python3.12/site-packages/numpy/__init__.cython-30.pxd":291 * @property * cdef inline npy_intp alignment(self) noexcept nogil: * return PyDataType_ALIGNMENT(self) # <<<<<<<<<<<<<< * * # Use fields/names with care as they may be NULL. You must check */ __pyx_r = PyDataType_ALIGNMENT(__pyx_v_self); goto __pyx_L0; /* "../../../../../tmp/build-env-2vlxkjf_/lib/python3.12/site-packages/numpy/__init__.cython-30.pxd":290 * * @property * cdef inline npy_intp alignment(self) noexcept nogil: # <<<<<<<<<<<<<< * return PyDataType_ALIGNMENT(self) * */ /* function exit code */ __pyx_L0:; return __pyx_r; } /* "../../../../../tmp/build-env-2vlxkjf_/lib/python3.12/site-packages/numpy/__init__.cython-30.pxd":296 * # for this using PyDataType_HASFIELDS. * @property * cdef inline object fields(self): # <<<<<<<<<<<<<< * return PyDataType_FIELDS(self) * */ static CYTHON_INLINE PyObject *__pyx_f_5numpy_5dtype_6fields_fields(PyArray_Descr *__pyx_v_self) { PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1; __Pyx_RefNannySetupContext("fields", 1); /* "../../../../../tmp/build-env-2vlxkjf_/lib/python3.12/site-packages/numpy/__init__.cython-30.pxd":297 * @property * cdef inline object fields(self): * return PyDataType_FIELDS(self) # <<<<<<<<<<<<<< * * @property */ __Pyx_XDECREF(__pyx_r); __pyx_t_1 = PyDataType_FIELDS(__pyx_v_self); __Pyx_INCREF(((PyObject *)__pyx_t_1)); __pyx_r = ((PyObject *)__pyx_t_1); goto __pyx_L0; /* "../../../../../tmp/build-env-2vlxkjf_/lib/python3.12/site-packages/numpy/__init__.cython-30.pxd":296 * # for this using PyDataType_HASFIELDS. * @property * cdef inline object fields(self): # <<<<<<<<<<<<<< * return PyDataType_FIELDS(self) * */ /* function exit code */ __pyx_L0:; __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "../../../../../tmp/build-env-2vlxkjf_/lib/python3.12/site-packages/numpy/__init__.cython-30.pxd":300 * * @property * cdef inline tuple names(self): # <<<<<<<<<<<<<< * return PyDataType_NAMES(self) * */ static CYTHON_INLINE PyObject *__pyx_f_5numpy_5dtype_5names_names(PyArray_Descr *__pyx_v_self) { PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1; __Pyx_RefNannySetupContext("names", 1); /* "../../../../../tmp/build-env-2vlxkjf_/lib/python3.12/site-packages/numpy/__init__.cython-30.pxd":301 * @property * cdef inline tuple names(self): * return PyDataType_NAMES(self) # <<<<<<<<<<<<<< * * # Use PyDataType_HASSUBARRAY to test whether this field is */ __Pyx_XDECREF(__pyx_r); __pyx_t_1 = PyDataType_NAMES(__pyx_v_self); __Pyx_INCREF(((PyObject*)__pyx_t_1)); __pyx_r = ((PyObject*)__pyx_t_1); goto __pyx_L0; /* "../../../../../tmp/build-env-2vlxkjf_/lib/python3.12/site-packages/numpy/__init__.cython-30.pxd":300 * * @property * cdef inline tuple names(self): # <<<<<<<<<<<<<< * return PyDataType_NAMES(self) * */ /* function exit code */ __pyx_L0:; __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "../../../../../tmp/build-env-2vlxkjf_/lib/python3.12/site-packages/numpy/__init__.cython-30.pxd":307 * # this field via the inline helper method PyDataType_SHAPE. * @property * cdef inline PyArray_ArrayDescr* subarray(self) noexcept nogil: # <<<<<<<<<<<<<< * return PyDataType_SUBARRAY(self) * */ static CYTHON_INLINE PyArray_ArrayDescr *__pyx_f_5numpy_5dtype_8subarray_subarray(PyArray_Descr *__pyx_v_self) { PyArray_ArrayDescr *__pyx_r; /* "../../../../../tmp/build-env-2vlxkjf_/lib/python3.12/site-packages/numpy/__init__.cython-30.pxd":308 * @property * cdef inline PyArray_ArrayDescr* subarray(self) noexcept nogil: * return PyDataType_SUBARRAY(self) # <<<<<<<<<<<<<< * * @property */ __pyx_r = PyDataType_SUBARRAY(__pyx_v_self); goto __pyx_L0; /* "../../../../../tmp/build-env-2vlxkjf_/lib/python3.12/site-packages/numpy/__init__.cython-30.pxd":307 * # this field via the inline helper method PyDataType_SHAPE. * @property * cdef inline PyArray_ArrayDescr* subarray(self) noexcept nogil: # <<<<<<<<<<<<<< * return PyDataType_SUBARRAY(self) * */ /* function exit code */ __pyx_L0:; return __pyx_r; } /* "../../../../../tmp/build-env-2vlxkjf_/lib/python3.12/site-packages/numpy/__init__.cython-30.pxd":311 * * @property * cdef inline npy_uint64 flags(self) noexcept nogil: # <<<<<<<<<<<<<< * """The data types flags.""" * return PyDataType_FLAGS(self) */ static CYTHON_INLINE npy_uint64 __pyx_f_5numpy_5dtype_5flags_flags(PyArray_Descr *__pyx_v_self) { npy_uint64 __pyx_r; /* "../../../../../tmp/build-env-2vlxkjf_/lib/python3.12/site-packages/numpy/__init__.cython-30.pxd":313 * cdef inline npy_uint64 flags(self) noexcept nogil: * """The data types flags.""" * return PyDataType_FLAGS(self) # <<<<<<<<<<<<<< * * */ __pyx_r = PyDataType_FLAGS(__pyx_v_self); goto __pyx_L0; /* "../../../../../tmp/build-env-2vlxkjf_/lib/python3.12/site-packages/numpy/__init__.cython-30.pxd":311 * * @property * cdef inline npy_uint64 flags(self) noexcept nogil: # <<<<<<<<<<<<<< * """The data types flags.""" * return PyDataType_FLAGS(self) */ /* function exit code */ __pyx_L0:; return __pyx_r; } /* "../../../../../tmp/build-env-2vlxkjf_/lib/python3.12/site-packages/numpy/__init__.cython-30.pxd":323 * * @property * cdef inline int numiter(self) noexcept nogil: # <<<<<<<<<<<<<< * """The number of arrays that need to be broadcast to the same shape.""" * return PyArray_MultiIter_NUMITER(self) */ static CYTHON_INLINE int __pyx_f_5numpy_9broadcast_7numiter_numiter(PyArrayMultiIterObject *__pyx_v_self) { int __pyx_r; /* "../../../../../tmp/build-env-2vlxkjf_/lib/python3.12/site-packages/numpy/__init__.cython-30.pxd":325 * cdef inline int numiter(self) noexcept nogil: * """The number of arrays that need to be broadcast to the same shape.""" * return PyArray_MultiIter_NUMITER(self) # <<<<<<<<<<<<<< * * @property */ __pyx_r = PyArray_MultiIter_NUMITER(__pyx_v_self); goto __pyx_L0; /* "../../../../../tmp/build-env-2vlxkjf_/lib/python3.12/site-packages/numpy/__init__.cython-30.pxd":323 * * @property * cdef inline int numiter(self) noexcept nogil: # <<<<<<<<<<<<<< * """The number of arrays that need to be broadcast to the same shape.""" * return PyArray_MultiIter_NUMITER(self) */ /* function exit code */ __pyx_L0:; return __pyx_r; } /* "../../../../../tmp/build-env-2vlxkjf_/lib/python3.12/site-packages/numpy/__init__.cython-30.pxd":328 * * @property * cdef inline npy_intp size(self) noexcept nogil: # <<<<<<<<<<<<<< * """The total broadcasted size.""" * return PyArray_MultiIter_SIZE(self) */ static CYTHON_INLINE npy_intp __pyx_f_5numpy_9broadcast_4size_size(PyArrayMultiIterObject *__pyx_v_self) { npy_intp __pyx_r; /* "../../../../../tmp/build-env-2vlxkjf_/lib/python3.12/site-packages/numpy/__init__.cython-30.pxd":330 * cdef inline npy_intp size(self) noexcept nogil: * """The total broadcasted size.""" * return PyArray_MultiIter_SIZE(self) # <<<<<<<<<<<<<< * * @property */ __pyx_r = PyArray_MultiIter_SIZE(__pyx_v_self); goto __pyx_L0; /* "../../../../../tmp/build-env-2vlxkjf_/lib/python3.12/site-packages/numpy/__init__.cython-30.pxd":328 * * @property * cdef inline npy_intp size(self) noexcept nogil: # <<<<<<<<<<<<<< * """The total broadcasted size.""" * return PyArray_MultiIter_SIZE(self) */ /* function exit code */ __pyx_L0:; return __pyx_r; } /* "../../../../../tmp/build-env-2vlxkjf_/lib/python3.12/site-packages/numpy/__init__.cython-30.pxd":333 * * @property * cdef inline npy_intp index(self) noexcept nogil: # <<<<<<<<<<<<<< * """The current (1-d) index into the broadcasted result.""" * return PyArray_MultiIter_INDEX(self) */ static CYTHON_INLINE npy_intp __pyx_f_5numpy_9broadcast_5index_index(PyArrayMultiIterObject *__pyx_v_self) { npy_intp __pyx_r; /* "../../../../../tmp/build-env-2vlxkjf_/lib/python3.12/site-packages/numpy/__init__.cython-30.pxd":335 * cdef inline npy_intp index(self) noexcept nogil: * """The current (1-d) index into the broadcasted result.""" * return PyArray_MultiIter_INDEX(self) # <<<<<<<<<<<<<< * * @property */ __pyx_r = PyArray_MultiIter_INDEX(__pyx_v_self); goto __pyx_L0; /* "../../../../../tmp/build-env-2vlxkjf_/lib/python3.12/site-packages/numpy/__init__.cython-30.pxd":333 * * @property * cdef inline npy_intp index(self) noexcept nogil: # <<<<<<<<<<<<<< * """The current (1-d) index into the broadcasted result.""" * return PyArray_MultiIter_INDEX(self) */ /* function exit code */ __pyx_L0:; return __pyx_r; } /* "../../../../../tmp/build-env-2vlxkjf_/lib/python3.12/site-packages/numpy/__init__.cython-30.pxd":338 * * @property * cdef inline int nd(self) noexcept nogil: # <<<<<<<<<<<<<< * """The number of dimensions in the broadcasted result.""" * return PyArray_MultiIter_NDIM(self) */ static CYTHON_INLINE int __pyx_f_5numpy_9broadcast_2nd_nd(PyArrayMultiIterObject *__pyx_v_self) { int __pyx_r; /* "../../../../../tmp/build-env-2vlxkjf_/lib/python3.12/site-packages/numpy/__init__.cython-30.pxd":340 * cdef inline int nd(self) noexcept nogil: * """The number of dimensions in the broadcasted result.""" * return PyArray_MultiIter_NDIM(self) # <<<<<<<<<<<<<< * * @property */ __pyx_r = PyArray_MultiIter_NDIM(__pyx_v_self); goto __pyx_L0; /* "../../../../../tmp/build-env-2vlxkjf_/lib/python3.12/site-packages/numpy/__init__.cython-30.pxd":338 * * @property * cdef inline int nd(self) noexcept nogil: # <<<<<<<<<<<<<< * """The number of dimensions in the broadcasted result.""" * return PyArray_MultiIter_NDIM(self) */ /* function exit code */ __pyx_L0:; return __pyx_r; } /* "../../../../../tmp/build-env-2vlxkjf_/lib/python3.12/site-packages/numpy/__init__.cython-30.pxd":343 * * @property * cdef inline npy_intp* dimensions(self) noexcept nogil: # <<<<<<<<<<<<<< * """The shape of the broadcasted result.""" * return PyArray_MultiIter_DIMS(self) */ static CYTHON_INLINE npy_intp *__pyx_f_5numpy_9broadcast_10dimensions_dimensions(PyArrayMultiIterObject *__pyx_v_self) { npy_intp *__pyx_r; /* "../../../../../tmp/build-env-2vlxkjf_/lib/python3.12/site-packages/numpy/__init__.cython-30.pxd":345 * cdef inline npy_intp* dimensions(self) noexcept nogil: * """The shape of the broadcasted result.""" * return PyArray_MultiIter_DIMS(self) # <<<<<<<<<<<<<< * * @property */ __pyx_r = PyArray_MultiIter_DIMS(__pyx_v_self); goto __pyx_L0; /* "../../../../../tmp/build-env-2vlxkjf_/lib/python3.12/site-packages/numpy/__init__.cython-30.pxd":343 * * @property * cdef inline npy_intp* dimensions(self) noexcept nogil: # <<<<<<<<<<<<<< * """The shape of the broadcasted result.""" * return PyArray_MultiIter_DIMS(self) */ /* function exit code */ __pyx_L0:; return __pyx_r; } /* "../../../../../tmp/build-env-2vlxkjf_/lib/python3.12/site-packages/numpy/__init__.cython-30.pxd":348 * * @property * cdef inline void** iters(self) noexcept nogil: # <<<<<<<<<<<<<< * """An array of iterator objects that holds the iterators for the arrays to be broadcast together. * On return, the iterators are adjusted for broadcasting.""" */ static CYTHON_INLINE void **__pyx_f_5numpy_9broadcast_5iters_iters(PyArrayMultiIterObject *__pyx_v_self) { void **__pyx_r; /* "../../../../../tmp/build-env-2vlxkjf_/lib/python3.12/site-packages/numpy/__init__.cython-30.pxd":351 * """An array of iterator objects that holds the iterators for the arrays to be broadcast together. * On return, the iterators are adjusted for broadcasting.""" * return PyArray_MultiIter_ITERS(self) # <<<<<<<<<<<<<< * * */ __pyx_r = PyArray_MultiIter_ITERS(__pyx_v_self); goto __pyx_L0; /* "../../../../../tmp/build-env-2vlxkjf_/lib/python3.12/site-packages/numpy/__init__.cython-30.pxd":348 * * @property * cdef inline void** iters(self) noexcept nogil: # <<<<<<<<<<<<<< * """An array of iterator objects that holds the iterators for the arrays to be broadcast together. * On return, the iterators are adjusted for broadcasting.""" */ /* function exit code */ __pyx_L0:; return __pyx_r; } /* "../../../../../tmp/build-env-2vlxkjf_/lib/python3.12/site-packages/numpy/__init__.cython-30.pxd":366 * * @property * cdef inline PyObject* base(self) noexcept nogil: # <<<<<<<<<<<<<< * """Returns a borrowed reference to the object owning the data/memory. * """ */ static CYTHON_INLINE PyObject *__pyx_f_5numpy_7ndarray_4base_base(PyArrayObject *__pyx_v_self) { PyObject *__pyx_r; /* "../../../../../tmp/build-env-2vlxkjf_/lib/python3.12/site-packages/numpy/__init__.cython-30.pxd":369 * """Returns a borrowed reference to the object owning the data/memory. * """ * return PyArray_BASE(self) # <<<<<<<<<<<<<< * * @property */ __pyx_r = PyArray_BASE(__pyx_v_self); goto __pyx_L0; /* "../../../../../tmp/build-env-2vlxkjf_/lib/python3.12/site-packages/numpy/__init__.cython-30.pxd":366 * * @property * cdef inline PyObject* base(self) noexcept nogil: # <<<<<<<<<<<<<< * """Returns a borrowed reference to the object owning the data/memory. * """ */ /* function exit code */ __pyx_L0:; return __pyx_r; } /* "../../../../../tmp/build-env-2vlxkjf_/lib/python3.12/site-packages/numpy/__init__.cython-30.pxd":372 * * @property * cdef inline dtype descr(self): # <<<<<<<<<<<<<< * """Returns an owned reference to the dtype of the array. * """ */ static CYTHON_INLINE PyArray_Descr *__pyx_f_5numpy_7ndarray_5descr_descr(PyArrayObject *__pyx_v_self) { PyArray_Descr *__pyx_r = NULL; __Pyx_RefNannyDeclarations PyArray_Descr *__pyx_t_1; __Pyx_RefNannySetupContext("descr", 1); /* "../../../../../tmp/build-env-2vlxkjf_/lib/python3.12/site-packages/numpy/__init__.cython-30.pxd":375 * """Returns an owned reference to the dtype of the array. * """ * return PyArray_DESCR(self) # <<<<<<<<<<<<<< * * @property */ __Pyx_XDECREF((PyObject *)__pyx_r); __pyx_t_1 = PyArray_DESCR(__pyx_v_self); __Pyx_INCREF((PyObject *)((PyArray_Descr *)__pyx_t_1)); __pyx_r = ((PyArray_Descr *)__pyx_t_1); goto __pyx_L0; /* "../../../../../tmp/build-env-2vlxkjf_/lib/python3.12/site-packages/numpy/__init__.cython-30.pxd":372 * * @property * cdef inline dtype descr(self): # <<<<<<<<<<<<<< * """Returns an owned reference to the dtype of the array. * """ */ /* function exit code */ __pyx_L0:; __Pyx_XGIVEREF((PyObject *)__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "../../../../../tmp/build-env-2vlxkjf_/lib/python3.12/site-packages/numpy/__init__.cython-30.pxd":378 * * @property * cdef inline int ndim(self) noexcept nogil: # <<<<<<<<<<<<<< * """Returns the number of dimensions in the array. * """ */ static CYTHON_INLINE int __pyx_f_5numpy_7ndarray_4ndim_ndim(PyArrayObject *__pyx_v_self) { int __pyx_r; /* "../../../../../tmp/build-env-2vlxkjf_/lib/python3.12/site-packages/numpy/__init__.cython-30.pxd":381 * """Returns the number of dimensions in the array. * """ * return PyArray_NDIM(self) # <<<<<<<<<<<<<< * * @property */ __pyx_r = PyArray_NDIM(__pyx_v_self); goto __pyx_L0; /* "../../../../../tmp/build-env-2vlxkjf_/lib/python3.12/site-packages/numpy/__init__.cython-30.pxd":378 * * @property * cdef inline int ndim(self) noexcept nogil: # <<<<<<<<<<<<<< * """Returns the number of dimensions in the array. * """ */ /* function exit code */ __pyx_L0:; return __pyx_r; } /* "../../../../../tmp/build-env-2vlxkjf_/lib/python3.12/site-packages/numpy/__init__.cython-30.pxd":384 * * @property * cdef inline npy_intp *shape(self) noexcept nogil: # <<<<<<<<<<<<<< * """Returns a pointer to the dimensions/shape of the array. * The number of elements matches the number of dimensions of the array (ndim). */ static CYTHON_INLINE npy_intp *__pyx_f_5numpy_7ndarray_5shape_shape(PyArrayObject *__pyx_v_self) { npy_intp *__pyx_r; /* "../../../../../tmp/build-env-2vlxkjf_/lib/python3.12/site-packages/numpy/__init__.cython-30.pxd":389 * Can return NULL for 0-dimensional arrays. * """ * return PyArray_DIMS(self) # <<<<<<<<<<<<<< * * @property */ __pyx_r = PyArray_DIMS(__pyx_v_self); goto __pyx_L0; /* "../../../../../tmp/build-env-2vlxkjf_/lib/python3.12/site-packages/numpy/__init__.cython-30.pxd":384 * * @property * cdef inline npy_intp *shape(self) noexcept nogil: # <<<<<<<<<<<<<< * """Returns a pointer to the dimensions/shape of the array. * The number of elements matches the number of dimensions of the array (ndim). */ /* function exit code */ __pyx_L0:; return __pyx_r; } /* "../../../../../tmp/build-env-2vlxkjf_/lib/python3.12/site-packages/numpy/__init__.cython-30.pxd":392 * * @property * cdef inline npy_intp *strides(self) noexcept nogil: # <<<<<<<<<<<<<< * """Returns a pointer to the strides of the array. * The number of elements matches the number of dimensions of the array (ndim). */ static CYTHON_INLINE npy_intp *__pyx_f_5numpy_7ndarray_7strides_strides(PyArrayObject *__pyx_v_self) { npy_intp *__pyx_r; /* "../../../../../tmp/build-env-2vlxkjf_/lib/python3.12/site-packages/numpy/__init__.cython-30.pxd":396 * The number of elements matches the number of dimensions of the array (ndim). * """ * return PyArray_STRIDES(self) # <<<<<<<<<<<<<< * * @property */ __pyx_r = PyArray_STRIDES(__pyx_v_self); goto __pyx_L0; /* "../../../../../tmp/build-env-2vlxkjf_/lib/python3.12/site-packages/numpy/__init__.cython-30.pxd":392 * * @property * cdef inline npy_intp *strides(self) noexcept nogil: # <<<<<<<<<<<<<< * """Returns a pointer to the strides of the array. * The number of elements matches the number of dimensions of the array (ndim). */ /* function exit code */ __pyx_L0:; return __pyx_r; } /* "../../../../../tmp/build-env-2vlxkjf_/lib/python3.12/site-packages/numpy/__init__.cython-30.pxd":399 * * @property * cdef inline npy_intp size(self) noexcept nogil: # <<<<<<<<<<<<<< * """Returns the total size (in number of elements) of the array. * """ */ static CYTHON_INLINE npy_intp __pyx_f_5numpy_7ndarray_4size_size(PyArrayObject *__pyx_v_self) { npy_intp __pyx_r; /* "../../../../../tmp/build-env-2vlxkjf_/lib/python3.12/site-packages/numpy/__init__.cython-30.pxd":402 * """Returns the total size (in number of elements) of the array. * """ * return PyArray_SIZE(self) # <<<<<<<<<<<<<< * * @property */ __pyx_r = PyArray_SIZE(__pyx_v_self); goto __pyx_L0; /* "../../../../../tmp/build-env-2vlxkjf_/lib/python3.12/site-packages/numpy/__init__.cython-30.pxd":399 * * @property * cdef inline npy_intp size(self) noexcept nogil: # <<<<<<<<<<<<<< * """Returns the total size (in number of elements) of the array. * """ */ /* function exit code */ __pyx_L0:; return __pyx_r; } /* "../../../../../tmp/build-env-2vlxkjf_/lib/python3.12/site-packages/numpy/__init__.cython-30.pxd":405 * * @property * cdef inline char* data(self) noexcept nogil: # <<<<<<<<<<<<<< * """The pointer to the data buffer as a char*. * This is provided for legacy reasons to avoid direct struct field access. */ static CYTHON_INLINE char *__pyx_f_5numpy_7ndarray_4data_data(PyArrayObject *__pyx_v_self) { char *__pyx_r; /* "../../../../../tmp/build-env-2vlxkjf_/lib/python3.12/site-packages/numpy/__init__.cython-30.pxd":411 * of `PyArray_DATA()` instead, which returns a 'void*'. * """ * return PyArray_BYTES(self) # <<<<<<<<<<<<<< * * */ __pyx_r = PyArray_BYTES(__pyx_v_self); goto __pyx_L0; /* "../../../../../tmp/build-env-2vlxkjf_/lib/python3.12/site-packages/numpy/__init__.cython-30.pxd":405 * * @property * cdef inline char* data(self) noexcept nogil: # <<<<<<<<<<<<<< * """The pointer to the data buffer as a char*. * This is provided for legacy reasons to avoid direct struct field access. */ /* function exit code */ __pyx_L0:; return __pyx_r; } /* "../../../../../tmp/build-env-2vlxkjf_/lib/python3.12/site-packages/numpy/__init__.cython-30.pxd":807 * ctypedef long double complex clongdouble_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", 1); /* "../../../../../tmp/build-env-2vlxkjf_/lib/python3.12/site-packages/numpy/__init__.cython-30.pxd":808 * * 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, 808, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_r = __pyx_t_1; __pyx_t_1 = 0; goto __pyx_L0; /* "../../../../../tmp/build-env-2vlxkjf_/lib/python3.12/site-packages/numpy/__init__.cython-30.pxd":807 * ctypedef long double complex clongdouble_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/build-env-2vlxkjf_/lib/python3.12/site-packages/numpy/__init__.cython-30.pxd":810 * 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", 1); /* "../../../../../tmp/build-env-2vlxkjf_/lib/python3.12/site-packages/numpy/__init__.cython-30.pxd":811 * * 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, 811, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_r = __pyx_t_1; __pyx_t_1 = 0; goto __pyx_L0; /* "../../../../../tmp/build-env-2vlxkjf_/lib/python3.12/site-packages/numpy/__init__.cython-30.pxd":810 * 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/build-env-2vlxkjf_/lib/python3.12/site-packages/numpy/__init__.cython-30.pxd":813 * 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", 1); /* "../../../../../tmp/build-env-2vlxkjf_/lib/python3.12/site-packages/numpy/__init__.cython-30.pxd":814 * * 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, 814, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_r = __pyx_t_1; __pyx_t_1 = 0; goto __pyx_L0; /* "../../../../../tmp/build-env-2vlxkjf_/lib/python3.12/site-packages/numpy/__init__.cython-30.pxd":813 * 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/build-env-2vlxkjf_/lib/python3.12/site-packages/numpy/__init__.cython-30.pxd":816 * 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", 1); /* "../../../../../tmp/build-env-2vlxkjf_/lib/python3.12/site-packages/numpy/__init__.cython-30.pxd":817 * * 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, 817, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_r = __pyx_t_1; __pyx_t_1 = 0; goto __pyx_L0; /* "../../../../../tmp/build-env-2vlxkjf_/lib/python3.12/site-packages/numpy/__init__.cython-30.pxd":816 * 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/build-env-2vlxkjf_/lib/python3.12/site-packages/numpy/__init__.cython-30.pxd":819 * 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", 1); /* "../../../../../tmp/build-env-2vlxkjf_/lib/python3.12/site-packages/numpy/__init__.cython-30.pxd":820 * * 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, 820, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_r = __pyx_t_1; __pyx_t_1 = 0; goto __pyx_L0; /* "../../../../../tmp/build-env-2vlxkjf_/lib/python3.12/site-packages/numpy/__init__.cython-30.pxd":819 * 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/build-env-2vlxkjf_/lib/python3.12/site-packages/numpy/__init__.cython-30.pxd":822 * 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; PyObject *__pyx_t_2; __Pyx_RefNannySetupContext("PyDataType_SHAPE", 1); /* "../../../../../tmp/build-env-2vlxkjf_/lib/python3.12/site-packages/numpy/__init__.cython-30.pxd":823 * * cdef inline tuple PyDataType_SHAPE(dtype d): * if PyDataType_HASSUBARRAY(d): # <<<<<<<<<<<<<< * return d.subarray.shape * else: */ __pyx_t_1 = PyDataType_HASSUBARRAY(__pyx_v_d); if (__pyx_t_1) { /* "../../../../../tmp/build-env-2vlxkjf_/lib/python3.12/site-packages/numpy/__init__.cython-30.pxd":824 * cdef inline tuple PyDataType_SHAPE(dtype d): * if PyDataType_HASSUBARRAY(d): * return d.subarray.shape # <<<<<<<<<<<<<< * else: * return () */ __Pyx_XDECREF(__pyx_r); __pyx_t_2 = __pyx_f_5numpy_5dtype_8subarray_subarray(__pyx_v_d)->shape; __Pyx_INCREF(((PyObject*)__pyx_t_2)); __pyx_r = ((PyObject*)__pyx_t_2); goto __pyx_L0; /* "../../../../../tmp/build-env-2vlxkjf_/lib/python3.12/site-packages/numpy/__init__.cython-30.pxd":823 * * cdef inline tuple PyDataType_SHAPE(dtype d): * if PyDataType_HASSUBARRAY(d): # <<<<<<<<<<<<<< * return d.subarray.shape * else: */ } /* "../../../../../tmp/build-env-2vlxkjf_/lib/python3.12/site-packages/numpy/__init__.cython-30.pxd":826 * 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/build-env-2vlxkjf_/lib/python3.12/site-packages/numpy/__init__.cython-30.pxd":822 * 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/build-env-2vlxkjf_/lib/python3.12/site-packages/numpy/__init__.cython-30.pxd":1010 * int _import_umath() except -1 * * cdef inline void set_array_base(ndarray arr, object base) except *: # <<<<<<<<<<<<<< * 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) { int __pyx_t_1; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; /* "../../../../../tmp/build-env-2vlxkjf_/lib/python3.12/site-packages/numpy/__init__.cython-30.pxd":1011 * * cdef inline void set_array_base(ndarray arr, object base) except *: * Py_INCREF(base) # important to do this before stealing the reference below! # <<<<<<<<<<<<<< * PyArray_SetBaseObject(arr, base) * */ Py_INCREF(__pyx_v_base); /* "../../../../../tmp/build-env-2vlxkjf_/lib/python3.12/site-packages/numpy/__init__.cython-30.pxd":1012 * cdef inline void set_array_base(ndarray arr, object base) except *: * Py_INCREF(base) # important to do this before stealing the reference below! * PyArray_SetBaseObject(arr, base) # <<<<<<<<<<<<<< * * cdef inline object get_array_base(ndarray arr): */ __pyx_t_1 = PyArray_SetBaseObject(__pyx_v_arr, __pyx_v_base); if (unlikely(__pyx_t_1 == ((int)-1))) __PYX_ERR(2, 1012, __pyx_L1_error) /* "../../../../../tmp/build-env-2vlxkjf_/lib/python3.12/site-packages/numpy/__init__.cython-30.pxd":1010 * int _import_umath() except -1 * * cdef inline void set_array_base(ndarray arr, object base) except *: # <<<<<<<<<<<<<< * Py_INCREF(base) # important to do this before stealing the reference below! * PyArray_SetBaseObject(arr, base) */ /* function exit code */ goto __pyx_L0; __pyx_L1_error:; __Pyx_AddTraceback("numpy.set_array_base", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_L0:; } /* "../../../../../tmp/build-env-2vlxkjf_/lib/python3.12/site-packages/numpy/__init__.cython-30.pxd":1014 * 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", 1); /* "../../../../../tmp/build-env-2vlxkjf_/lib/python3.12/site-packages/numpy/__init__.cython-30.pxd":1015 * * 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/build-env-2vlxkjf_/lib/python3.12/site-packages/numpy/__init__.cython-30.pxd":1016 * 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); if (__pyx_t_1) { /* "../../../../../tmp/build-env-2vlxkjf_/lib/python3.12/site-packages/numpy/__init__.cython-30.pxd":1017 * 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/build-env-2vlxkjf_/lib/python3.12/site-packages/numpy/__init__.cython-30.pxd":1016 * cdef inline object get_array_base(ndarray arr): * base = PyArray_BASE(arr) * if base is NULL: # <<<<<<<<<<<<<< * return None * return base */ } /* "../../../../../tmp/build-env-2vlxkjf_/lib/python3.12/site-packages/numpy/__init__.cython-30.pxd":1018 * 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/build-env-2vlxkjf_/lib/python3.12/site-packages/numpy/__init__.cython-30.pxd":1014 * 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/build-env-2vlxkjf_/lib/python3.12/site-packages/numpy/__init__.cython-30.pxd":1022 * # 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", 1); /* "../../../../../tmp/build-env-2vlxkjf_/lib/python3.12/site-packages/numpy/__init__.cython-30.pxd":1023 * # 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/build-env-2vlxkjf_/lib/python3.12/site-packages/numpy/__init__.cython-30.pxd":1024 * 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, 1024, __pyx_L3_error) /* "../../../../../tmp/build-env-2vlxkjf_/lib/python3.12/site-packages/numpy/__init__.cython-30.pxd":1023 * # 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/build-env-2vlxkjf_/lib/python3.12/site-packages/numpy/__init__.cython-30.pxd":1025 * 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, 1025, __pyx_L5_except_error) __Pyx_XGOTREF(__pyx_t_5); __Pyx_XGOTREF(__pyx_t_6); __Pyx_XGOTREF(__pyx_t_7); /* "../../../../../tmp/build-env-2vlxkjf_/lib/python3.12/site-packages/numpy/__init__.cython-30.pxd":1026 * __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__9, NULL); if (unlikely(!__pyx_t_8)) __PYX_ERR(2, 1026, __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, 1026, __pyx_L5_except_error) } goto __pyx_L5_except_error; /* "../../../../../tmp/build-env-2vlxkjf_/lib/python3.12/site-packages/numpy/__init__.cython-30.pxd":1023 * # Cython code. * cdef inline int import_array() except -1: * try: # <<<<<<<<<<<<<< * __pyx_import_array() * except Exception: */ __pyx_L5_except_error:; __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/build-env-2vlxkjf_/lib/python3.12/site-packages/numpy/__init__.cython-30.pxd":1022 * # 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/build-env-2vlxkjf_/lib/python3.12/site-packages/numpy/__init__.cython-30.pxd":1028 * 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", 1); /* "../../../../../tmp/build-env-2vlxkjf_/lib/python3.12/site-packages/numpy/__init__.cython-30.pxd":1029 * * 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/build-env-2vlxkjf_/lib/python3.12/site-packages/numpy/__init__.cython-30.pxd":1030 * 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, 1030, __pyx_L3_error) /* "../../../../../tmp/build-env-2vlxkjf_/lib/python3.12/site-packages/numpy/__init__.cython-30.pxd":1029 * * 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/build-env-2vlxkjf_/lib/python3.12/site-packages/numpy/__init__.cython-30.pxd":1031 * 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, 1031, __pyx_L5_except_error) __Pyx_XGOTREF(__pyx_t_5); __Pyx_XGOTREF(__pyx_t_6); __Pyx_XGOTREF(__pyx_t_7); /* "../../../../../tmp/build-env-2vlxkjf_/lib/python3.12/site-packages/numpy/__init__.cython-30.pxd":1032 * _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__10, NULL); if (unlikely(!__pyx_t_8)) __PYX_ERR(2, 1032, __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, 1032, __pyx_L5_except_error) } goto __pyx_L5_except_error; /* "../../../../../tmp/build-env-2vlxkjf_/lib/python3.12/site-packages/numpy/__init__.cython-30.pxd":1029 * * cdef inline int import_umath() except -1: * try: # <<<<<<<<<<<<<< * _import_umath() * except Exception: */ __pyx_L5_except_error:; __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/build-env-2vlxkjf_/lib/python3.12/site-packages/numpy/__init__.cython-30.pxd":1028 * 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/build-env-2vlxkjf_/lib/python3.12/site-packages/numpy/__init__.cython-30.pxd":1034 * 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", 1); /* "../../../../../tmp/build-env-2vlxkjf_/lib/python3.12/site-packages/numpy/__init__.cython-30.pxd":1035 * * 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/build-env-2vlxkjf_/lib/python3.12/site-packages/numpy/__init__.cython-30.pxd":1036 * 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, 1036, __pyx_L3_error) /* "../../../../../tmp/build-env-2vlxkjf_/lib/python3.12/site-packages/numpy/__init__.cython-30.pxd":1035 * * 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/build-env-2vlxkjf_/lib/python3.12/site-packages/numpy/__init__.cython-30.pxd":1037 * 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, 1037, __pyx_L5_except_error) __Pyx_XGOTREF(__pyx_t_5); __Pyx_XGOTREF(__pyx_t_6); __Pyx_XGOTREF(__pyx_t_7); /* "../../../../../tmp/build-env-2vlxkjf_/lib/python3.12/site-packages/numpy/__init__.cython-30.pxd":1038 * _import_umath() * except Exception: * raise ImportError("numpy._core.umath failed to import") # <<<<<<<<<<<<<< * * */ __pyx_t_8 = __Pyx_PyObject_Call(__pyx_builtin_ImportError, __pyx_tuple__10, NULL); if (unlikely(!__pyx_t_8)) __PYX_ERR(2, 1038, __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, 1038, __pyx_L5_except_error) } goto __pyx_L5_except_error; /* "../../../../../tmp/build-env-2vlxkjf_/lib/python3.12/site-packages/numpy/__init__.cython-30.pxd":1035 * * cdef inline int import_ufunc() except -1: * try: # <<<<<<<<<<<<<< * _import_umath() * except Exception: */ __pyx_L5_except_error:; __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/build-env-2vlxkjf_/lib/python3.12/site-packages/numpy/__init__.cython-30.pxd":1034 * 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/build-env-2vlxkjf_/lib/python3.12/site-packages/numpy/__init__.cython-30.pxd":1041 * * * cdef inline bint is_timedelta64_object(object obj) noexcept: # <<<<<<<<<<<<<< * """ * Cython equivalent of `isinstance(obj, np.timedelta64)` */ static CYTHON_INLINE int __pyx_f_5numpy_is_timedelta64_object(PyObject *__pyx_v_obj) { int __pyx_r; /* "../../../../../tmp/build-env-2vlxkjf_/lib/python3.12/site-packages/numpy/__init__.cython-30.pxd":1053 * bool * """ * return PyObject_TypeCheck(obj, &PyTimedeltaArrType_Type) # <<<<<<<<<<<<<< * * */ __pyx_r = PyObject_TypeCheck(__pyx_v_obj, (&PyTimedeltaArrType_Type)); goto __pyx_L0; /* "../../../../../tmp/build-env-2vlxkjf_/lib/python3.12/site-packages/numpy/__init__.cython-30.pxd":1041 * * * cdef inline bint is_timedelta64_object(object obj) noexcept: # <<<<<<<<<<<<<< * """ * Cython equivalent of `isinstance(obj, np.timedelta64)` */ /* function exit code */ __pyx_L0:; return __pyx_r; } /* "../../../../../tmp/build-env-2vlxkjf_/lib/python3.12/site-packages/numpy/__init__.cython-30.pxd":1056 * * * cdef inline bint is_datetime64_object(object obj) noexcept: # <<<<<<<<<<<<<< * """ * Cython equivalent of `isinstance(obj, np.datetime64)` */ static CYTHON_INLINE int __pyx_f_5numpy_is_datetime64_object(PyObject *__pyx_v_obj) { int __pyx_r; /* "../../../../../tmp/build-env-2vlxkjf_/lib/python3.12/site-packages/numpy/__init__.cython-30.pxd":1068 * bool * """ * return PyObject_TypeCheck(obj, &PyDatetimeArrType_Type) # <<<<<<<<<<<<<< * * */ __pyx_r = PyObject_TypeCheck(__pyx_v_obj, (&PyDatetimeArrType_Type)); goto __pyx_L0; /* "../../../../../tmp/build-env-2vlxkjf_/lib/python3.12/site-packages/numpy/__init__.cython-30.pxd":1056 * * * cdef inline bint is_datetime64_object(object obj) noexcept: # <<<<<<<<<<<<<< * """ * Cython equivalent of `isinstance(obj, np.datetime64)` */ /* function exit code */ __pyx_L0:; return __pyx_r; } /* "../../../../../tmp/build-env-2vlxkjf_/lib/python3.12/site-packages/numpy/__init__.cython-30.pxd":1071 * * * cdef inline npy_datetime get_datetime64_value(object obj) noexcept 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/build-env-2vlxkjf_/lib/python3.12/site-packages/numpy/__init__.cython-30.pxd":1078 * also needed. That can be found using `get_datetime64_unit`. * """ * return (obj).obval # <<<<<<<<<<<<<< * * */ __pyx_r = ((PyDatetimeScalarObject *)__pyx_v_obj)->obval; goto __pyx_L0; /* "../../../../../tmp/build-env-2vlxkjf_/lib/python3.12/site-packages/numpy/__init__.cython-30.pxd":1071 * * * cdef inline npy_datetime get_datetime64_value(object obj) noexcept nogil: # <<<<<<<<<<<<<< * """ * returns the int64 value underlying scalar numpy datetime64 object */ /* function exit code */ __pyx_L0:; return __pyx_r; } /* "../../../../../tmp/build-env-2vlxkjf_/lib/python3.12/site-packages/numpy/__init__.cython-30.pxd":1081 * * * cdef inline npy_timedelta get_timedelta64_value(object obj) noexcept 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/build-env-2vlxkjf_/lib/python3.12/site-packages/numpy/__init__.cython-30.pxd":1085 * returns the int64 value underlying scalar numpy timedelta64 object * """ * return (obj).obval # <<<<<<<<<<<<<< * * */ __pyx_r = ((PyTimedeltaScalarObject *)__pyx_v_obj)->obval; goto __pyx_L0; /* "../../../../../tmp/build-env-2vlxkjf_/lib/python3.12/site-packages/numpy/__init__.cython-30.pxd":1081 * * * cdef inline npy_timedelta get_timedelta64_value(object obj) noexcept nogil: # <<<<<<<<<<<<<< * """ * returns the int64 value underlying scalar numpy timedelta64 object */ /* function exit code */ __pyx_L0:; return __pyx_r; } /* "../../../../../tmp/build-env-2vlxkjf_/lib/python3.12/site-packages/numpy/__init__.cython-30.pxd":1088 * * * cdef inline NPY_DATETIMEUNIT get_datetime64_unit(object obj) noexcept 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/build-env-2vlxkjf_/lib/python3.12/site-packages/numpy/__init__.cython-30.pxd":1092 * 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/build-env-2vlxkjf_/lib/python3.12/site-packages/numpy/__init__.cython-30.pxd":1088 * * * cdef inline NPY_DATETIMEUNIT get_datetime64_unit(object obj) noexcept nogil: # <<<<<<<<<<<<<< * """ * returns the unit part of the dtype for a numpy datetime64 object. */ /* function exit code */ __pyx_L0:; return __pyx_r; } /* "astroscrappy/astroscrappy.pyx":26 * from libc.stdlib cimport malloc, free * * def detect_cosmics(indat, inmask=None, inbkg=None, invar=None, float sigclip=4.5, # <<<<<<<<<<<<<< * float sigfrac=0.3, float objlim=5.0, float gain=1.0, * float readnoise=6.5, float satlevel=65536.0, */ /* Python wrapper */ static PyObject *__pyx_pw_12astroscrappy_12astroscrappy_1detect_cosmics(PyObject *__pyx_self, #if CYTHON_METH_FASTCALL PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds #else PyObject *__pyx_args, PyObject *__pyx_kwds #endif ); /*proto*/ PyDoc_STRVAR(__pyx_doc_12astroscrappy_12astroscrappy_detect_cosmics, "detect_cosmics(indat, inmask=None, inbkg=None, invar=None, sigclip=4.5,\n sigfrac=0.3, objlim=5.0, gain=1.0, readnoise=6.5,\n satlevel=65536.0, niter=4, sepmed=True,\n cleantype='meanmask', fsmode='median', psfmodel='gauss',\n psffwhm=2.5, psfsize=7, psfk=None, psfbeta=4.765,\n verbose=False)\n\n Detect cosmic rays in a numpy array.\n\n If you use this code, please cite the Zendo DOI: https://zenodo.org/record/1482019\n\n Please cite the original paper which can be found at:\n http://www.astro.yale.edu/dokkum/lacosmic/\n\n van Dokkum 2001, PASP, 113, 789, 1420\n (article : http://adsabs.harvard.edu/abs/2001PASP..113.1420V)\n\n Parameters\n ----------\n indat : float numpy array\n Input data array that will be used for cosmic ray detection. This\n should include the sky background (or a mean background level, added\n back in after sky subtraction), so that noise can be estimated\n correctly from the data values. This should be in units of \"counts\".\n\n inmask : boolean numpy array, optional\n Input bad pixel mask. Values of True will be ignored in the cosmic ray\n detection/cleaning process. Default: None.\n\n inbkg : float numpy array, optional\n A pre-determined background image, to be subtracted from ``indat``\n before running the main detection algorithm.\n This is used primarily with spectroscopic data, to remove\n sky lines and the cross-section of an object continuum during\n iteration, \"protecting\" them from spurious rejection (see the above\n paper). This background is not removed from the final, cleaned output\n (`cleanarr`). This should be in units of \"counts\", the same units of indat.\n This inbkg should be free from cosmic rays. When estimating the cosmic-ray\n free noise of the image, we will treat ``inbkg`` ""as a constant Poisson\n contribution to the variance.\n\n invar : float numpy array, optional\n A pre-determined estimate of the data variance (ie. noise squared) in\n each pixel, generated by previous processing of ``indat``. If provided,\n this is used in place of an internal noise model based on ``indat``,\n ``gain`` and ``readnoise``. This still gets median filtered and cleaned\n internally, to estimate what the noise in each pixel *would* be in the\n absence of cosmic rays. This should be in units of \"counts\" squared.\n\n sigclip : float, optional\n Laplacian-to-noise limit for cosmic ray detection. Lower values will\n flag more pixels as cosmic rays. Default: 4.5.\n\n sigfrac : float, optional\n Fractional detection limit for neighboring pixels. For cosmic ray\n neighbor pixels, a lapacian-to-noise detection limit of\n sigfrac * sigclip will be used. Default: 0.3.\n\n objlim : float, optional\n Minimum contrast between Laplacian image and the fine structure image.\n Increase this value if cores of bright stars are flagged as cosmic\n rays. Default: 5.0.\n\n gain : float, optional\n Gain of the image (electrons / ADU). We always need to work in\n electrons for cosmic ray detection. Default: 1.0\n\n readnoise : float, optional\n Read noise of the image (electrons). Used to generate the noise model\n of the image. Default: 6.5.\n\n satlevel : float, optional\n Saturation of level of the image (electrons). This value is used to\n detect saturated stars and pixels at or above this level are added to\n the mask. Default: 65536.0.\n\n niter : int, optional\n Number of iterations of the LA Cosmic algorithm to perform. Default: 4.\n\n sepmed : boolean, optional\n Use the separable median filter instead of the full median filter.\n The separable median is not identical ""to the full median filter, but\n they are approximately the same and the separable median filter is\n significantly faster and still detects cosmic rays well. Default: True\n\n cleantype : {'median', 'medmask', 'meanmask', 'idw'}, optional\n Set which clean algorithm is used:\n\n 'median': An umasked 5x5 median filter\n\n 'medmask': A masked 5x5 median filter\n\n 'meanmask': A masked 5x5 mean filter\n\n 'idw': A masked 5x5 inverse distance weighted interpolation\n\n Default: \"meanmask\".\n\n fsmode : {'median', 'convolve'}, optional\n Method to build the fine structure image:\n\n 'median': Use the median filter in the standard LA Cosmic algorithm\n 'convolve': Convolve the image with the psf kernel to calculate the\n fine structure image using a matched filter technique.\n Default: 'median'.\n\n psfmodel : {'gauss', 'gaussx', 'gaussy', 'moffat'}, optional\n Model to use to generate the psf kernel if fsmode == 'convolve' and\n psfk is None. The current choices are Gaussian and Moffat profiles.\n 'gauss' and 'moffat' produce circular PSF kernels. The 'gaussx' and\n 'gaussy' produce Gaussian kernels in the x and y directions\n respectively. Default: \"gauss\".\n\n psffwhm : float, optional\n Full Width Half Maximum of the PSF to use to generate the kernel.\n Default: 2.5.\n\n psfsize : int, optional\n Size of the kernel to calculate. Returned kernel will have size\n psfsize x psfsize. psfsize should be odd. Default: 7.\n\n psfk : float numpy array, optional\n PSF kernel array to use for the fine structure image if\n fsmode == 'convolve'. If None and fsmode == 'convolve', we calculate\n the psf kernel using 'psfmodel'. Default: None.\n\n psfbeta : float, optional\n Moffat beta parameter. Only used if fsmode=='convolve' and\n psfmodel=='moffat'. Default: 4.765.""\n\n verbose : boolean, optional\n Print to the screen or not. Default: False.\n\n Returns\n -------\n crmask : boolean numpy array\n The cosmic ray mask (boolean) array with values of True where there are\n cosmic ray detections.\n\n cleanarr : float numpy array\n The cleaned data array.\n\n Notes\n -----\n To reproduce the most similar behavior to the original LA Cosmic\n (written in IRAF), set inmask = None, satlevel = np.inf, sepmed=False,\n cleantype='medmask', and fsmode='median'.\n\n The original IRAF version distinguishes between spectroscopic and imaging\n data. This version does not.\n\n For best results on spectra, we recommend that you include an estimate of the background.\n One can generally obtain this by fitting columns with a smooth function. To efficiently identify\n cosmic rays, LA Cosmic and therefore astroscrappy estimates the cosmic ray free noise by smoothing\n the variance using a median filter. To minimize false positives on bright sky lines, if ``inbkg`` is\n provided, we do not smooth the variance contribution from the provided background. We only smooth\n the variance that is in addition to the Poisson contribution from the background so that we do\n not underestimate the noise (and therefore run the risk of flagging false positives) near narrow, bright\n sky lines.\n "); static PyMethodDef __pyx_mdef_12astroscrappy_12astroscrappy_1detect_cosmics = {"detect_cosmics", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_12astroscrappy_12astroscrappy_1detect_cosmics, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_12astroscrappy_12astroscrappy_detect_cosmics}; static PyObject *__pyx_pw_12astroscrappy_12astroscrappy_1detect_cosmics(PyObject *__pyx_self, #if CYTHON_METH_FASTCALL PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds #else PyObject *__pyx_args, PyObject *__pyx_kwds #endif ) { PyObject *__pyx_v_indat = 0; PyObject *__pyx_v_inmask = 0; PyObject *__pyx_v_inbkg = 0; PyObject *__pyx_v_invar = 0; float __pyx_v_sigclip; float __pyx_v_sigfrac; float __pyx_v_objlim; float __pyx_v_gain; float __pyx_v_readnoise; float __pyx_v_satlevel; int __pyx_v_niter; PyObject *__pyx_v_sepmed = 0; PyObject *__pyx_v_cleantype = 0; PyObject *__pyx_v_fsmode = 0; PyObject *__pyx_v_psfmodel = 0; float __pyx_v_psffwhm; int __pyx_v_psfsize; PyObject *__pyx_v_psfk = 0; float __pyx_v_psfbeta; PyObject *__pyx_v_verbose = 0; #if !CYTHON_METH_FASTCALL CYTHON_UNUSED Py_ssize_t __pyx_nargs; #endif CYTHON_UNUSED PyObject *const *__pyx_kwvalues; PyObject* values[20] = {0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,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("detect_cosmics (wrapper)", 0); #if !CYTHON_METH_FASTCALL #if CYTHON_ASSUME_SAFE_MACROS __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); #else __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; #endif #endif __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); { PyObject **__pyx_pyargnames[] = {&__pyx_n_s_indat,&__pyx_n_s_inmask,&__pyx_n_s_inbkg,&__pyx_n_s_invar,&__pyx_n_s_sigclip,&__pyx_n_s_sigfrac,&__pyx_n_s_objlim,&__pyx_n_s_gain,&__pyx_n_s_readnoise,&__pyx_n_s_satlevel,&__pyx_n_s_niter,&__pyx_n_s_sepmed,&__pyx_n_s_cleantype,&__pyx_n_s_fsmode,&__pyx_n_s_psfmodel,&__pyx_n_s_psffwhm,&__pyx_n_s_psfsize,&__pyx_n_s_psfk,&__pyx_n_s_psfbeta,&__pyx_n_s_verbose,0}; values[1] = __Pyx_Arg_NewRef_FASTCALL(((PyObject *)Py_None)); values[2] = __Pyx_Arg_NewRef_FASTCALL(((PyObject *)Py_None)); values[3] = __Pyx_Arg_NewRef_FASTCALL(((PyObject *)Py_None)); /* "astroscrappy/astroscrappy.pyx":29 * float sigfrac=0.3, float objlim=5.0, float gain=1.0, * float readnoise=6.5, float satlevel=65536.0, * int niter=4, sepmed=True, cleantype='meanmask', # <<<<<<<<<<<<<< * fsmode='median', psfmodel='gauss', float psffwhm=2.5, * int psfsize=7, psfk=None, float psfbeta=4.765, */ values[11] = __Pyx_Arg_NewRef_FASTCALL(((PyObject *)((PyObject *)Py_True))); values[12] = __Pyx_Arg_NewRef_FASTCALL(((PyObject *)((PyObject*)__pyx_n_u_meanmask))); values[13] = __Pyx_Arg_NewRef_FASTCALL(((PyObject *)((PyObject*)__pyx_n_u_median))); values[14] = __Pyx_Arg_NewRef_FASTCALL(((PyObject *)((PyObject*)__pyx_n_u_gauss))); /* "astroscrappy/astroscrappy.pyx":31 * int niter=4, sepmed=True, cleantype='meanmask', * fsmode='median', psfmodel='gauss', float psffwhm=2.5, * int psfsize=7, psfk=None, float psfbeta=4.765, # <<<<<<<<<<<<<< * verbose=False): * """detect_cosmics(indat, inmask=None, inbkg=None, invar=None, sigclip=4.5, */ values[17] = __Pyx_Arg_NewRef_FASTCALL(((PyObject *)Py_None)); /* "astroscrappy/astroscrappy.pyx":32 * fsmode='median', psfmodel='gauss', float psffwhm=2.5, * int psfsize=7, psfk=None, float psfbeta=4.765, * verbose=False): # <<<<<<<<<<<<<< * """detect_cosmics(indat, inmask=None, inbkg=None, invar=None, sigclip=4.5, * sigfrac=0.3, objlim=5.0, gain=1.0, readnoise=6.5, */ values[19] = __Pyx_Arg_NewRef_FASTCALL(((PyObject *)((PyObject *)Py_False))); if (__pyx_kwds) { Py_ssize_t kw_args; switch (__pyx_nargs) { case 20: values[19] = __Pyx_Arg_FASTCALL(__pyx_args, 19); CYTHON_FALLTHROUGH; case 19: values[18] = __Pyx_Arg_FASTCALL(__pyx_args, 18); CYTHON_FALLTHROUGH; case 18: values[17] = __Pyx_Arg_FASTCALL(__pyx_args, 17); CYTHON_FALLTHROUGH; case 17: values[16] = __Pyx_Arg_FASTCALL(__pyx_args, 16); CYTHON_FALLTHROUGH; case 16: values[15] = __Pyx_Arg_FASTCALL(__pyx_args, 15); CYTHON_FALLTHROUGH; case 15: values[14] = __Pyx_Arg_FASTCALL(__pyx_args, 14); CYTHON_FALLTHROUGH; case 14: values[13] = __Pyx_Arg_FASTCALL(__pyx_args, 13); CYTHON_FALLTHROUGH; case 13: values[12] = __Pyx_Arg_FASTCALL(__pyx_args, 12); CYTHON_FALLTHROUGH; case 12: values[11] = __Pyx_Arg_FASTCALL(__pyx_args, 11); CYTHON_FALLTHROUGH; case 11: values[10] = __Pyx_Arg_FASTCALL(__pyx_args, 10); CYTHON_FALLTHROUGH; case 10: values[9] = __Pyx_Arg_FASTCALL(__pyx_args, 9); CYTHON_FALLTHROUGH; case 9: values[8] = __Pyx_Arg_FASTCALL(__pyx_args, 8); CYTHON_FALLTHROUGH; case 8: values[7] = __Pyx_Arg_FASTCALL(__pyx_args, 7); CYTHON_FALLTHROUGH; case 7: values[6] = __Pyx_Arg_FASTCALL(__pyx_args, 6); CYTHON_FALLTHROUGH; case 6: values[5] = __Pyx_Arg_FASTCALL(__pyx_args, 5); CYTHON_FALLTHROUGH; case 5: values[4] = __Pyx_Arg_FASTCALL(__pyx_args, 4); CYTHON_FALLTHROUGH; case 4: values[3] = __Pyx_Arg_FASTCALL(__pyx_args, 3); CYTHON_FALLTHROUGH; case 3: values[2] = __Pyx_Arg_FASTCALL(__pyx_args, 2); CYTHON_FALLTHROUGH; case 2: values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); CYTHON_FALLTHROUGH; case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); CYTHON_FALLTHROUGH; case 0: break; default: goto __pyx_L5_argtuple_error; } kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); switch (__pyx_nargs) { case 0: if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_indat)) != 0)) { (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); kw_args--; } else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 26, __pyx_L3_error) else goto __pyx_L5_argtuple_error; CYTHON_FALLTHROUGH; case 1: if (kw_args > 0) { PyObject* value = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_inmask); if (value) { values[1] = __Pyx_Arg_NewRef_FASTCALL(value); kw_args--; } else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 26, __pyx_L3_error) } CYTHON_FALLTHROUGH; case 2: if (kw_args > 0) { PyObject* value = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_inbkg); if (value) { values[2] = __Pyx_Arg_NewRef_FASTCALL(value); kw_args--; } else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 26, __pyx_L3_error) } CYTHON_FALLTHROUGH; case 3: if (kw_args > 0) { PyObject* value = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_invar); if (value) { values[3] = __Pyx_Arg_NewRef_FASTCALL(value); kw_args--; } else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 26, __pyx_L3_error) } CYTHON_FALLTHROUGH; case 4: if (kw_args > 0) { PyObject* value = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_sigclip); if (value) { values[4] = __Pyx_Arg_NewRef_FASTCALL(value); kw_args--; } else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 26, __pyx_L3_error) } CYTHON_FALLTHROUGH; case 5: if (kw_args > 0) { PyObject* value = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_sigfrac); if (value) { values[5] = __Pyx_Arg_NewRef_FASTCALL(value); kw_args--; } else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 26, __pyx_L3_error) } CYTHON_FALLTHROUGH; case 6: if (kw_args > 0) { PyObject* value = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_objlim); if (value) { values[6] = __Pyx_Arg_NewRef_FASTCALL(value); kw_args--; } else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 26, __pyx_L3_error) } CYTHON_FALLTHROUGH; case 7: if (kw_args > 0) { PyObject* value = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_gain); if (value) { values[7] = __Pyx_Arg_NewRef_FASTCALL(value); kw_args--; } else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 26, __pyx_L3_error) } CYTHON_FALLTHROUGH; case 8: if (kw_args > 0) { PyObject* value = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_readnoise); if (value) { values[8] = __Pyx_Arg_NewRef_FASTCALL(value); kw_args--; } else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 26, __pyx_L3_error) } CYTHON_FALLTHROUGH; case 9: if (kw_args > 0) { PyObject* value = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_satlevel); if (value) { values[9] = __Pyx_Arg_NewRef_FASTCALL(value); kw_args--; } else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 26, __pyx_L3_error) } CYTHON_FALLTHROUGH; case 10: if (kw_args > 0) { PyObject* value = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_niter); if (value) { values[10] = __Pyx_Arg_NewRef_FASTCALL(value); kw_args--; } else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 26, __pyx_L3_error) } CYTHON_FALLTHROUGH; case 11: if (kw_args > 0) { PyObject* value = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_sepmed); if (value) { values[11] = __Pyx_Arg_NewRef_FASTCALL(value); kw_args--; } else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 26, __pyx_L3_error) } CYTHON_FALLTHROUGH; case 12: if (kw_args > 0) { PyObject* value = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_cleantype); if (value) { values[12] = __Pyx_Arg_NewRef_FASTCALL(value); kw_args--; } else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 26, __pyx_L3_error) } CYTHON_FALLTHROUGH; case 13: if (kw_args > 0) { PyObject* value = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_fsmode); if (value) { values[13] = __Pyx_Arg_NewRef_FASTCALL(value); kw_args--; } else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 26, __pyx_L3_error) } CYTHON_FALLTHROUGH; case 14: if (kw_args > 0) { PyObject* value = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_psfmodel); if (value) { values[14] = __Pyx_Arg_NewRef_FASTCALL(value); kw_args--; } else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 26, __pyx_L3_error) } CYTHON_FALLTHROUGH; case 15: if (kw_args > 0) { PyObject* value = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_psffwhm); if (value) { values[15] = __Pyx_Arg_NewRef_FASTCALL(value); kw_args--; } else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 26, __pyx_L3_error) } CYTHON_FALLTHROUGH; case 16: if (kw_args > 0) { PyObject* value = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_psfsize); if (value) { values[16] = __Pyx_Arg_NewRef_FASTCALL(value); kw_args--; } else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 26, __pyx_L3_error) } CYTHON_FALLTHROUGH; case 17: if (kw_args > 0) { PyObject* value = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_psfk); if (value) { values[17] = __Pyx_Arg_NewRef_FASTCALL(value); kw_args--; } else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 26, __pyx_L3_error) } CYTHON_FALLTHROUGH; case 18: if (kw_args > 0) { PyObject* value = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_psfbeta); if (value) { values[18] = __Pyx_Arg_NewRef_FASTCALL(value); kw_args--; } else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 26, __pyx_L3_error) } CYTHON_FALLTHROUGH; case 19: if (kw_args > 0) { PyObject* value = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_verbose); if (value) { values[19] = __Pyx_Arg_NewRef_FASTCALL(value); kw_args--; } else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 26, __pyx_L3_error) } } if (unlikely(kw_args > 0)) { const Py_ssize_t kwd_pos_args = __pyx_nargs; if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "detect_cosmics") < 0)) __PYX_ERR(0, 26, __pyx_L3_error) } } else { switch (__pyx_nargs) { case 20: values[19] = __Pyx_Arg_FASTCALL(__pyx_args, 19); CYTHON_FALLTHROUGH; case 19: values[18] = __Pyx_Arg_FASTCALL(__pyx_args, 18); CYTHON_FALLTHROUGH; case 18: values[17] = __Pyx_Arg_FASTCALL(__pyx_args, 17); CYTHON_FALLTHROUGH; case 17: values[16] = __Pyx_Arg_FASTCALL(__pyx_args, 16); CYTHON_FALLTHROUGH; case 16: values[15] = __Pyx_Arg_FASTCALL(__pyx_args, 15); CYTHON_FALLTHROUGH; case 15: values[14] = __Pyx_Arg_FASTCALL(__pyx_args, 14); CYTHON_FALLTHROUGH; case 14: values[13] = __Pyx_Arg_FASTCALL(__pyx_args, 13); CYTHON_FALLTHROUGH; case 13: values[12] = __Pyx_Arg_FASTCALL(__pyx_args, 12); CYTHON_FALLTHROUGH; case 12: values[11] = __Pyx_Arg_FASTCALL(__pyx_args, 11); CYTHON_FALLTHROUGH; case 11: values[10] = __Pyx_Arg_FASTCALL(__pyx_args, 10); CYTHON_FALLTHROUGH; case 10: values[9] = __Pyx_Arg_FASTCALL(__pyx_args, 9); CYTHON_FALLTHROUGH; case 9: values[8] = __Pyx_Arg_FASTCALL(__pyx_args, 8); CYTHON_FALLTHROUGH; case 8: values[7] = __Pyx_Arg_FASTCALL(__pyx_args, 7); CYTHON_FALLTHROUGH; case 7: values[6] = __Pyx_Arg_FASTCALL(__pyx_args, 6); CYTHON_FALLTHROUGH; case 6: values[5] = __Pyx_Arg_FASTCALL(__pyx_args, 5); CYTHON_FALLTHROUGH; case 5: values[4] = __Pyx_Arg_FASTCALL(__pyx_args, 4); CYTHON_FALLTHROUGH; case 4: values[3] = __Pyx_Arg_FASTCALL(__pyx_args, 3); CYTHON_FALLTHROUGH; case 3: values[2] = __Pyx_Arg_FASTCALL(__pyx_args, 2); CYTHON_FALLTHROUGH; case 2: values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); CYTHON_FALLTHROUGH; case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); break; default: goto __pyx_L5_argtuple_error; } } __pyx_v_indat = values[0]; __pyx_v_inmask = values[1]; __pyx_v_inbkg = values[2]; __pyx_v_invar = values[3]; if (values[4]) { __pyx_v_sigclip = __pyx_PyFloat_AsFloat(values[4]); if (unlikely((__pyx_v_sigclip == (float)-1) && PyErr_Occurred())) __PYX_ERR(0, 26, __pyx_L3_error) } else { __pyx_v_sigclip = ((float)((double)4.5)); } if (values[5]) { __pyx_v_sigfrac = __pyx_PyFloat_AsFloat(values[5]); if (unlikely((__pyx_v_sigfrac == (float)-1) && PyErr_Occurred())) __PYX_ERR(0, 27, __pyx_L3_error) } else { __pyx_v_sigfrac = ((float)((double)0.3)); } if (values[6]) { __pyx_v_objlim = __pyx_PyFloat_AsFloat(values[6]); if (unlikely((__pyx_v_objlim == (float)-1) && PyErr_Occurred())) __PYX_ERR(0, 27, __pyx_L3_error) } else { __pyx_v_objlim = ((float)((double)5.0)); } if (values[7]) { __pyx_v_gain = __pyx_PyFloat_AsFloat(values[7]); if (unlikely((__pyx_v_gain == (float)-1) && PyErr_Occurred())) __PYX_ERR(0, 27, __pyx_L3_error) } else { __pyx_v_gain = ((float)((double)1.0)); } if (values[8]) { __pyx_v_readnoise = __pyx_PyFloat_AsFloat(values[8]); if (unlikely((__pyx_v_readnoise == (float)-1) && PyErr_Occurred())) __PYX_ERR(0, 28, __pyx_L3_error) } else { __pyx_v_readnoise = ((float)((double)6.5)); } if (values[9]) { __pyx_v_satlevel = __pyx_PyFloat_AsFloat(values[9]); if (unlikely((__pyx_v_satlevel == (float)-1) && PyErr_Occurred())) __PYX_ERR(0, 28, __pyx_L3_error) } else { __pyx_v_satlevel = ((float)((double)65536.0)); } if (values[10]) { __pyx_v_niter = __Pyx_PyInt_As_int(values[10]); if (unlikely((__pyx_v_niter == (int)-1) && PyErr_Occurred())) __PYX_ERR(0, 29, __pyx_L3_error) } else { __pyx_v_niter = ((int)((int)4)); } __pyx_v_sepmed = values[11]; __pyx_v_cleantype = values[12]; __pyx_v_fsmode = values[13]; __pyx_v_psfmodel = values[14]; if (values[15]) { __pyx_v_psffwhm = __pyx_PyFloat_AsFloat(values[15]); if (unlikely((__pyx_v_psffwhm == (float)-1) && PyErr_Occurred())) __PYX_ERR(0, 30, __pyx_L3_error) } else { __pyx_v_psffwhm = ((float)((double)2.5)); } if (values[16]) { __pyx_v_psfsize = __Pyx_PyInt_As_int(values[16]); if (unlikely((__pyx_v_psfsize == (int)-1) && PyErr_Occurred())) __PYX_ERR(0, 31, __pyx_L3_error) } else { __pyx_v_psfsize = ((int)((int)7)); } __pyx_v_psfk = values[17]; if (values[18]) { __pyx_v_psfbeta = __pyx_PyFloat_AsFloat(values[18]); if (unlikely((__pyx_v_psfbeta == (float)-1) && PyErr_Occurred())) __PYX_ERR(0, 31, __pyx_L3_error) } else { __pyx_v_psfbeta = ((float)((double)4.765)); } __pyx_v_verbose = values[19]; } goto __pyx_L6_skip; __pyx_L5_argtuple_error:; __Pyx_RaiseArgtupleInvalid("detect_cosmics", 0, 1, 20, __pyx_nargs); __PYX_ERR(0, 26, __pyx_L3_error) __pyx_L6_skip:; goto __pyx_L4_argument_unpacking_done; __pyx_L3_error:; { Py_ssize_t __pyx_temp; for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); } } __Pyx_AddTraceback("astroscrappy.astroscrappy.detect_cosmics", __pyx_clineno, __pyx_lineno, __pyx_filename); __Pyx_RefNannyFinishContext(); return NULL; __pyx_L4_argument_unpacking_done:; __pyx_r = __pyx_pf_12astroscrappy_12astroscrappy_detect_cosmics(__pyx_self, __pyx_v_indat, __pyx_v_inmask, __pyx_v_inbkg, __pyx_v_invar, __pyx_v_sigclip, __pyx_v_sigfrac, __pyx_v_objlim, __pyx_v_gain, __pyx_v_readnoise, __pyx_v_satlevel, __pyx_v_niter, __pyx_v_sepmed, __pyx_v_cleantype, __pyx_v_fsmode, __pyx_v_psfmodel, __pyx_v_psffwhm, __pyx_v_psfsize, __pyx_v_psfk, __pyx_v_psfbeta, __pyx_v_verbose); /* "astroscrappy/astroscrappy.pyx":26 * from libc.stdlib cimport malloc, free * * def detect_cosmics(indat, inmask=None, inbkg=None, invar=None, float sigclip=4.5, # <<<<<<<<<<<<<< * float sigfrac=0.3, float objlim=5.0, float gain=1.0, * float readnoise=6.5, float satlevel=65536.0, */ /* function exit code */ { Py_ssize_t __pyx_temp; for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); } } __Pyx_RefNannyFinishContext(); return __pyx_r; } static PyObject *__pyx_pf_12astroscrappy_12astroscrappy_detect_cosmics(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_indat, PyObject *__pyx_v_inmask, PyObject *__pyx_v_inbkg, PyObject *__pyx_v_invar, float __pyx_v_sigclip, float __pyx_v_sigfrac, float __pyx_v_objlim, float __pyx_v_gain, float __pyx_v_readnoise, float __pyx_v_satlevel, int __pyx_v_niter, PyObject *__pyx_v_sepmed, PyObject *__pyx_v_cleantype, PyObject *__pyx_v_fsmode, PyObject *__pyx_v_psfmodel, float __pyx_v_psffwhm, int __pyx_v_psfsize, PyObject *__pyx_v_psfk, float __pyx_v_psfbeta, PyObject *__pyx_v_verbose) { int __pyx_v_nx; int __pyx_v_ny; int __pyx_v_i; CYTHON_UNUSED int __pyx_v_j; PyObject *__pyx_v_cleanarr = NULL; PyObject *__pyx_v_bkg = NULL; PyObject *__pyx_v_mask = NULL; PyObject *__pyx_v_clean_var = NULL; PyObject *__pyx_v_gooddata = NULL; CYTHON_UNUSED long __pyx_v_igoodpix; PyObject *__pyx_v_background_level = NULL; PyObject *__pyx_v_goodvar = NULL; PyObject *__pyx_v_background_var_level = NULL; PyObject *__pyx_v_crmask = NULL; float __pyx_v_sigcliplow; PyObject *__pyx_v_subsam = NULL; PyObject *__pyx_v_conved = NULL; PyObject *__pyx_v_s = NULL; PyObject *__pyx_v_m5 = NULL; PyObject *__pyx_v_noise = NULL; PyObject *__pyx_v_sp = NULL; PyObject *__pyx_v_goodpix = NULL; PyObject *__pyx_v_cosmics = NULL; PyObject *__pyx_v_f = NULL; PyObject *__pyx_v_m7 = NULL; PyObject *__pyx_v_numcr = NULL; PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; PyObject *__pyx_t_2 = NULL; int __pyx_t_3; PyObject *__pyx_t_4 = NULL; PyObject *__pyx_t_5 = NULL; PyObject *__pyx_t_6 = NULL; int __pyx_t_7; int __pyx_t_8; PyObject *__pyx_t_9 = NULL; Py_ssize_t __pyx_t_10; int __pyx_t_11; int __pyx_t_12; int __pyx_t_13; __Pyx_memviewslice __pyx_t_14 = { 0, 0, { 0 }, { 0 }, { 0 } }; __Pyx_memviewslice __pyx_t_15 = { 0, 0, { 0 }, { 0 }, { 0 } }; __Pyx_memviewslice __pyx_t_16 = { 0, 0, { 0 }, { 0 }, { 0 } }; float __pyx_t_17; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("detect_cosmics", 0); __Pyx_INCREF(__pyx_v_psfk); /* "astroscrappy/astroscrappy.pyx":188 * * # Grab the sizes of the input array * cdef int nx = indat.shape[1] # <<<<<<<<<<<<<< * cdef int ny = indat.shape[0] * */ __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_indat, __pyx_n_s_shape); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 188, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_t_2 = __Pyx_GetItemInt(__pyx_t_1, 1, long, 1, __Pyx_PyInt_From_long, 0, 0, 0); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 188, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __pyx_t_3 = __Pyx_PyInt_As_int(__pyx_t_2); if (unlikely((__pyx_t_3 == (int)-1) && PyErr_Occurred())) __PYX_ERR(0, 188, __pyx_L1_error) __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; __pyx_v_nx = __pyx_t_3; /* "astroscrappy/astroscrappy.pyx":189 * # Grab the sizes of the input array * cdef int nx = indat.shape[1] * cdef int ny = indat.shape[0] # <<<<<<<<<<<<<< * * # Tell the compiler about the loop indices so it can optimize them. */ __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_v_indat, __pyx_n_s_shape); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 189, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __pyx_t_1 = __Pyx_GetItemInt(__pyx_t_2, 0, long, 1, __Pyx_PyInt_From_long, 0, 0, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 189, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; __pyx_t_3 = __Pyx_PyInt_As_int(__pyx_t_1); if (unlikely((__pyx_t_3 == (int)-1) && PyErr_Occurred())) __PYX_ERR(0, 189, __pyx_L1_error) __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __pyx_v_ny = __pyx_t_3; /* "astroscrappy/astroscrappy.pyx":192 * * # Tell the compiler about the loop indices so it can optimize them. * cdef int i, j = 0 # <<<<<<<<<<<<<< * * # Make a copy of the data as the cleanarr that we work on */ __pyx_v_j = 0; /* "astroscrappy/astroscrappy.pyx":197 * # This guarantees that that the data will be contiguous and makes sure we * # don't edit the input data. * cleanarr = np.empty((ny, nx), dtype=np.float32, order='C') # <<<<<<<<<<<<<< * # Set the initial values to those of the data array * # Multiply by the gain; the statistics only work properly with electrons. */ __Pyx_GetModuleGlobalName(__pyx_t_1, __pyx_n_s_np); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 197, __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, 197, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __pyx_t_1 = __Pyx_PyInt_From_int(__pyx_v_ny); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 197, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_t_4 = __Pyx_PyInt_From_int(__pyx_v_nx); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 197, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __pyx_t_5 = PyTuple_New(2); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 197, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_5); __Pyx_GIVEREF(__pyx_t_1); if (__Pyx_PyTuple_SET_ITEM(__pyx_t_5, 0, __pyx_t_1)) __PYX_ERR(0, 197, __pyx_L1_error); __Pyx_GIVEREF(__pyx_t_4); if (__Pyx_PyTuple_SET_ITEM(__pyx_t_5, 1, __pyx_t_4)) __PYX_ERR(0, 197, __pyx_L1_error); __pyx_t_1 = 0; __pyx_t_4 = 0; __pyx_t_4 = PyTuple_New(1); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 197, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __Pyx_GIVEREF(__pyx_t_5); if (__Pyx_PyTuple_SET_ITEM(__pyx_t_4, 0, __pyx_t_5)) __PYX_ERR(0, 197, __pyx_L1_error); __pyx_t_5 = 0; __pyx_t_5 = __Pyx_PyDict_NewPresized(2); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 197, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_5); __Pyx_GetModuleGlobalName(__pyx_t_1, __pyx_n_s_np); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 197, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_t_1, __pyx_n_s_float32); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 197, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; if (PyDict_SetItem(__pyx_t_5, __pyx_n_s_dtype, __pyx_t_6) < 0) __PYX_ERR(0, 197, __pyx_L1_error) __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; if (PyDict_SetItem(__pyx_t_5, __pyx_n_s_order, __pyx_n_u_C) < 0) __PYX_ERR(0, 197, __pyx_L1_error) __pyx_t_6 = __Pyx_PyObject_Call(__pyx_t_2, __pyx_t_4, __pyx_t_5); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 197, __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_5); __pyx_t_5 = 0; __pyx_v_cleanarr = __pyx_t_6; __pyx_t_6 = 0; /* "astroscrappy/astroscrappy.pyx":200 * # Set the initial values to those of the data array * # Multiply by the gain; the statistics only work properly with electrons. * cleanarr[:, :] = indat[:, :] * gain # <<<<<<<<<<<<<< * * if inbkg is not None: */ __pyx_t_6 = __Pyx_PyObject_GetItem(__pyx_v_indat, __pyx_tuple__11); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 200, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); __pyx_t_5 = PyFloat_FromDouble(__pyx_v_gain); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 200, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_5); __pyx_t_4 = PyNumber_Multiply(__pyx_t_6, __pyx_t_5); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 200, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; if (unlikely((PyObject_SetItem(__pyx_v_cleanarr, __pyx_tuple__11, __pyx_t_4) < 0))) __PYX_ERR(0, 200, __pyx_L1_error) __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; /* "astroscrappy/astroscrappy.pyx":202 * cleanarr[:, :] = indat[:, :] * gain * * if inbkg is not None: # <<<<<<<<<<<<<< * bkg = np.empty((ny, nx), dtype=np.float32, order='C') * bkg[:, :] = inbkg[:, :] * gain */ __pyx_t_7 = (__pyx_v_inbkg != Py_None); if (__pyx_t_7) { /* "astroscrappy/astroscrappy.pyx":203 * * if inbkg is not None: * bkg = np.empty((ny, nx), dtype=np.float32, order='C') # <<<<<<<<<<<<<< * bkg[:, :] = inbkg[:, :] * gain * */ __Pyx_GetModuleGlobalName(__pyx_t_4, __pyx_n_s_np); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 203, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_t_4, __pyx_n_s_empty); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 203, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_5); __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __pyx_t_4 = __Pyx_PyInt_From_int(__pyx_v_ny); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 203, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __pyx_t_6 = __Pyx_PyInt_From_int(__pyx_v_nx); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 203, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); __pyx_t_2 = PyTuple_New(2); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 203, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __Pyx_GIVEREF(__pyx_t_4); if (__Pyx_PyTuple_SET_ITEM(__pyx_t_2, 0, __pyx_t_4)) __PYX_ERR(0, 203, __pyx_L1_error); __Pyx_GIVEREF(__pyx_t_6); if (__Pyx_PyTuple_SET_ITEM(__pyx_t_2, 1, __pyx_t_6)) __PYX_ERR(0, 203, __pyx_L1_error); __pyx_t_4 = 0; __pyx_t_6 = 0; __pyx_t_6 = PyTuple_New(1); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 203, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); __Pyx_GIVEREF(__pyx_t_2); if (__Pyx_PyTuple_SET_ITEM(__pyx_t_6, 0, __pyx_t_2)) __PYX_ERR(0, 203, __pyx_L1_error); __pyx_t_2 = 0; __pyx_t_2 = __Pyx_PyDict_NewPresized(2); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 203, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __Pyx_GetModuleGlobalName(__pyx_t_4, __pyx_n_s_np); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 203, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_t_4, __pyx_n_s_float32); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 203, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; if (PyDict_SetItem(__pyx_t_2, __pyx_n_s_dtype, __pyx_t_1) < 0) __PYX_ERR(0, 203, __pyx_L1_error) __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; if (PyDict_SetItem(__pyx_t_2, __pyx_n_s_order, __pyx_n_u_C) < 0) __PYX_ERR(0, 203, __pyx_L1_error) __pyx_t_1 = __Pyx_PyObject_Call(__pyx_t_5, __pyx_t_6, __pyx_t_2); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 203, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; __pyx_v_bkg = __pyx_t_1; __pyx_t_1 = 0; /* "astroscrappy/astroscrappy.pyx":204 * if inbkg is not None: * bkg = np.empty((ny, nx), dtype=np.float32, order='C') * bkg[:, :] = inbkg[:, :] * gain # <<<<<<<<<<<<<< * * # Setup the mask */ __pyx_t_1 = __Pyx_PyObject_GetItem(__pyx_v_inbkg, __pyx_tuple__11); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 204, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_t_2 = PyFloat_FromDouble(__pyx_v_gain); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 204, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __pyx_t_6 = PyNumber_Multiply(__pyx_t_1, __pyx_t_2); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 204, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; if (unlikely((PyObject_SetItem(__pyx_v_bkg, __pyx_tuple__11, __pyx_t_6) < 0))) __PYX_ERR(0, 204, __pyx_L1_error) __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; /* "astroscrappy/astroscrappy.pyx":202 * cleanarr[:, :] = indat[:, :] * gain * * if inbkg is not None: # <<<<<<<<<<<<<< * bkg = np.empty((ny, nx), dtype=np.float32, order='C') * bkg[:, :] = inbkg[:, :] * gain */ } /* "astroscrappy/astroscrappy.pyx":207 * * # Setup the mask * if inmask is None: # <<<<<<<<<<<<<< * # By default don't mask anything * mask = np.zeros((ny, nx), dtype=np.uint8, order='C') */ __pyx_t_7 = (__pyx_v_inmask == Py_None); if (__pyx_t_7) { /* "astroscrappy/astroscrappy.pyx":209 * if inmask is None: * # By default don't mask anything * mask = np.zeros((ny, nx), dtype=np.uint8, order='C') # <<<<<<<<<<<<<< * else: * # Make a copy of the input mask */ __Pyx_GetModuleGlobalName(__pyx_t_6, __pyx_n_s_np); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 209, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_t_6, __pyx_n_s_zeros); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 209, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; __pyx_t_6 = __Pyx_PyInt_From_int(__pyx_v_ny); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 209, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); __pyx_t_1 = __Pyx_PyInt_From_int(__pyx_v_nx); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 209, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_t_5 = PyTuple_New(2); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 209, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_5); __Pyx_GIVEREF(__pyx_t_6); if (__Pyx_PyTuple_SET_ITEM(__pyx_t_5, 0, __pyx_t_6)) __PYX_ERR(0, 209, __pyx_L1_error); __Pyx_GIVEREF(__pyx_t_1); if (__Pyx_PyTuple_SET_ITEM(__pyx_t_5, 1, __pyx_t_1)) __PYX_ERR(0, 209, __pyx_L1_error); __pyx_t_6 = 0; __pyx_t_1 = 0; __pyx_t_1 = PyTuple_New(1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 209, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_GIVEREF(__pyx_t_5); if (__Pyx_PyTuple_SET_ITEM(__pyx_t_1, 0, __pyx_t_5)) __PYX_ERR(0, 209, __pyx_L1_error); __pyx_t_5 = 0; __pyx_t_5 = __Pyx_PyDict_NewPresized(2); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 209, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_5); __Pyx_GetModuleGlobalName(__pyx_t_6, __pyx_n_s_np); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 209, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_t_6, __pyx_n_s_uint8); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 209, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; if (PyDict_SetItem(__pyx_t_5, __pyx_n_s_dtype, __pyx_t_4) < 0) __PYX_ERR(0, 209, __pyx_L1_error) __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; if (PyDict_SetItem(__pyx_t_5, __pyx_n_s_order, __pyx_n_u_C) < 0) __PYX_ERR(0, 209, __pyx_L1_error) __pyx_t_4 = __Pyx_PyObject_Call(__pyx_t_2, __pyx_t_1, __pyx_t_5); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 209, __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_5); __pyx_t_5 = 0; __pyx_v_mask = __pyx_t_4; __pyx_t_4 = 0; /* "astroscrappy/astroscrappy.pyx":207 * * # Setup the mask * if inmask is None: # <<<<<<<<<<<<<< * # By default don't mask anything * mask = np.zeros((ny, nx), dtype=np.uint8, order='C') */ goto __pyx_L4; } /* "astroscrappy/astroscrappy.pyx":212 * else: * # Make a copy of the input mask * mask = np.empty((ny, nx), dtype=np.uint8, order='C') # <<<<<<<<<<<<<< * mask[:, :] = inmask[:, :] * */ /*else*/ { __Pyx_GetModuleGlobalName(__pyx_t_4, __pyx_n_s_np); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 212, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_t_4, __pyx_n_s_empty); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 212, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_5); __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __pyx_t_4 = __Pyx_PyInt_From_int(__pyx_v_ny); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 212, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __pyx_t_1 = __Pyx_PyInt_From_int(__pyx_v_nx); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 212, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_t_2 = PyTuple_New(2); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 212, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __Pyx_GIVEREF(__pyx_t_4); if (__Pyx_PyTuple_SET_ITEM(__pyx_t_2, 0, __pyx_t_4)) __PYX_ERR(0, 212, __pyx_L1_error); __Pyx_GIVEREF(__pyx_t_1); if (__Pyx_PyTuple_SET_ITEM(__pyx_t_2, 1, __pyx_t_1)) __PYX_ERR(0, 212, __pyx_L1_error); __pyx_t_4 = 0; __pyx_t_1 = 0; __pyx_t_1 = PyTuple_New(1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 212, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_GIVEREF(__pyx_t_2); if (__Pyx_PyTuple_SET_ITEM(__pyx_t_1, 0, __pyx_t_2)) __PYX_ERR(0, 212, __pyx_L1_error); __pyx_t_2 = 0; __pyx_t_2 = __Pyx_PyDict_NewPresized(2); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 212, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __Pyx_GetModuleGlobalName(__pyx_t_4, __pyx_n_s_np); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 212, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_t_4, __pyx_n_s_uint8); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 212, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; if (PyDict_SetItem(__pyx_t_2, __pyx_n_s_dtype, __pyx_t_6) < 0) __PYX_ERR(0, 212, __pyx_L1_error) __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; if (PyDict_SetItem(__pyx_t_2, __pyx_n_s_order, __pyx_n_u_C) < 0) __PYX_ERR(0, 212, __pyx_L1_error) __pyx_t_6 = __Pyx_PyObject_Call(__pyx_t_5, __pyx_t_1, __pyx_t_2); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 212, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; __pyx_v_mask = __pyx_t_6; __pyx_t_6 = 0; /* "astroscrappy/astroscrappy.pyx":213 * # Make a copy of the input mask * mask = np.empty((ny, nx), dtype=np.uint8, order='C') * mask[:, :] = inmask[:, :] # <<<<<<<<<<<<<< * * # Copy any noise estimates so we can clean them like the data, otherwise */ __pyx_t_6 = __Pyx_PyObject_GetItem(__pyx_v_inmask, __pyx_tuple__11); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 213, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); if (unlikely((PyObject_SetItem(__pyx_v_mask, __pyx_tuple__11, __pyx_t_6) < 0))) __PYX_ERR(0, 213, __pyx_L1_error) __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; } __pyx_L4:; /* "astroscrappy/astroscrappy.pyx":217 * # Copy any noise estimates so we can clean them like the data, otherwise * # use the main data array instead. * if invar is not None and inbkg is not None: # <<<<<<<<<<<<<< * clean_var = invar * (gain * gain) - bkg * elif invar is not None and inbkg is None: */ __pyx_t_8 = (__pyx_v_invar != Py_None); if (__pyx_t_8) { } else { __pyx_t_7 = __pyx_t_8; goto __pyx_L6_bool_binop_done; } __pyx_t_8 = (__pyx_v_inbkg != Py_None); __pyx_t_7 = __pyx_t_8; __pyx_L6_bool_binop_done:; if (__pyx_t_7) { /* "astroscrappy/astroscrappy.pyx":218 * # use the main data array instead. * if invar is not None and inbkg is not None: * clean_var = invar * (gain * gain) - bkg # <<<<<<<<<<<<<< * elif invar is not None and inbkg is None: * clean_var = invar * (gain * gain) */ __pyx_t_6 = PyFloat_FromDouble((__pyx_v_gain * __pyx_v_gain)); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 218, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); __pyx_t_2 = PyNumber_Multiply(__pyx_v_invar, __pyx_t_6); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 218, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; if (unlikely(!__pyx_v_bkg)) { __Pyx_RaiseUnboundLocalError("bkg"); __PYX_ERR(0, 218, __pyx_L1_error) } __pyx_t_6 = PyNumber_Subtract(__pyx_t_2, __pyx_v_bkg); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 218, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; __pyx_v_clean_var = __pyx_t_6; __pyx_t_6 = 0; /* "astroscrappy/astroscrappy.pyx":217 * # Copy any noise estimates so we can clean them like the data, otherwise * # use the main data array instead. * if invar is not None and inbkg is not None: # <<<<<<<<<<<<<< * clean_var = invar * (gain * gain) - bkg * elif invar is not None and inbkg is None: */ goto __pyx_L5; } /* "astroscrappy/astroscrappy.pyx":219 * if invar is not None and inbkg is not None: * clean_var = invar * (gain * gain) - bkg * elif invar is not None and inbkg is None: # <<<<<<<<<<<<<< * clean_var = invar * (gain * gain) * elif invar is None and inbkg is not None: */ __pyx_t_8 = (__pyx_v_invar != Py_None); if (__pyx_t_8) { } else { __pyx_t_7 = __pyx_t_8; goto __pyx_L8_bool_binop_done; } __pyx_t_8 = (__pyx_v_inbkg == Py_None); __pyx_t_7 = __pyx_t_8; __pyx_L8_bool_binop_done:; if (__pyx_t_7) { /* "astroscrappy/astroscrappy.pyx":220 * clean_var = invar * (gain * gain) - bkg * elif invar is not None and inbkg is None: * clean_var = invar * (gain * gain) # <<<<<<<<<<<<<< * elif invar is None and inbkg is not None: * clean_var = cleanarr - bkg + readnoise * readnoise */ __pyx_t_6 = PyFloat_FromDouble((__pyx_v_gain * __pyx_v_gain)); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 220, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); __pyx_t_2 = PyNumber_Multiply(__pyx_v_invar, __pyx_t_6); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 220, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; __pyx_v_clean_var = __pyx_t_2; __pyx_t_2 = 0; /* "astroscrappy/astroscrappy.pyx":219 * if invar is not None and inbkg is not None: * clean_var = invar * (gain * gain) - bkg * elif invar is not None and inbkg is None: # <<<<<<<<<<<<<< * clean_var = invar * (gain * gain) * elif invar is None and inbkg is not None: */ goto __pyx_L5; } /* "astroscrappy/astroscrappy.pyx":221 * elif invar is not None and inbkg is None: * clean_var = invar * (gain * gain) * elif invar is None and inbkg is not None: # <<<<<<<<<<<<<< * clean_var = cleanarr - bkg + readnoise * readnoise * else: */ __pyx_t_8 = (__pyx_v_invar == Py_None); if (__pyx_t_8) { } else { __pyx_t_7 = __pyx_t_8; goto __pyx_L10_bool_binop_done; } __pyx_t_8 = (__pyx_v_inbkg != Py_None); __pyx_t_7 = __pyx_t_8; __pyx_L10_bool_binop_done:; if (__pyx_t_7) { /* "astroscrappy/astroscrappy.pyx":222 * clean_var = invar * (gain * gain) * elif invar is None and inbkg is not None: * clean_var = cleanarr - bkg + readnoise * readnoise # <<<<<<<<<<<<<< * else: * clean_var = cleanarr + readnoise * readnoise */ if (unlikely(!__pyx_v_bkg)) { __Pyx_RaiseUnboundLocalError("bkg"); __PYX_ERR(0, 222, __pyx_L1_error) } __pyx_t_2 = PyNumber_Subtract(__pyx_v_cleanarr, __pyx_v_bkg); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 222, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __pyx_t_6 = PyFloat_FromDouble((__pyx_v_readnoise * __pyx_v_readnoise)); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 222, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); __pyx_t_1 = PyNumber_Add(__pyx_t_2, __pyx_t_6); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 222, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; __pyx_v_clean_var = __pyx_t_1; __pyx_t_1 = 0; /* "astroscrappy/astroscrappy.pyx":221 * elif invar is not None and inbkg is None: * clean_var = invar * (gain * gain) * elif invar is None and inbkg is not None: # <<<<<<<<<<<<<< * clean_var = cleanarr - bkg + readnoise * readnoise * else: */ goto __pyx_L5; } /* "astroscrappy/astroscrappy.pyx":224 * clean_var = cleanarr - bkg + readnoise * readnoise * else: * clean_var = cleanarr + readnoise * readnoise # <<<<<<<<<<<<<< * * # Find the saturated stars and add them to the mask */ /*else*/ { __pyx_t_1 = PyFloat_FromDouble((__pyx_v_readnoise * __pyx_v_readnoise)); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 224, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_t_6 = PyNumber_Add(__pyx_v_cleanarr, __pyx_t_1); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 224, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __pyx_v_clean_var = __pyx_t_6; __pyx_t_6 = 0; } __pyx_L5:; /* "astroscrappy/astroscrappy.pyx":227 * * # Find the saturated stars and add them to the mask * update_mask(np.asarray(cleanarr), np.asarray(mask), satlevel, sepmed) # <<<<<<<<<<<<<< * * # Subtract the input sky model, if applicable. */ __Pyx_GetModuleGlobalName(__pyx_t_1, __pyx_n_s_update_mask); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 227, __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, 227, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_5); __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_t_5, __pyx_n_s_asarray); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 227, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; __pyx_t_5 = NULL; __pyx_t_3 = 0; #if CYTHON_UNPACK_METHODS if (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 = 1; } } #endif { PyObject *__pyx_callargs[2] = {__pyx_t_5, __pyx_v_cleanarr}; __pyx_t_2 = __Pyx_PyObject_FastCall(__pyx_t_4, __pyx_callargs+1-__pyx_t_3, 1+__pyx_t_3); __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0; if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 227, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; } __Pyx_GetModuleGlobalName(__pyx_t_5, __pyx_n_s_np); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 227, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_5); __pyx_t_9 = __Pyx_PyObject_GetAttrStr(__pyx_t_5, __pyx_n_s_asarray); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 227, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_9); __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; __pyx_t_5 = NULL; __pyx_t_3 = 0; #if CYTHON_UNPACK_METHODS if (unlikely(PyMethod_Check(__pyx_t_9))) { __pyx_t_5 = PyMethod_GET_SELF(__pyx_t_9); if (likely(__pyx_t_5)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_9); __Pyx_INCREF(__pyx_t_5); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_9, function); __pyx_t_3 = 1; } } #endif { PyObject *__pyx_callargs[2] = {__pyx_t_5, __pyx_v_mask}; __pyx_t_4 = __Pyx_PyObject_FastCall(__pyx_t_9, __pyx_callargs+1-__pyx_t_3, 1+__pyx_t_3); __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0; if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 227, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; } __pyx_t_9 = PyFloat_FromDouble(__pyx_v_satlevel); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 227, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_9); __pyx_t_5 = NULL; __pyx_t_3 = 0; #if CYTHON_UNPACK_METHODS if (unlikely(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_3 = 1; } } #endif { PyObject *__pyx_callargs[5] = {__pyx_t_5, __pyx_t_2, __pyx_t_4, __pyx_t_9, __pyx_v_sepmed}; __pyx_t_6 = __Pyx_PyObject_FastCall(__pyx_t_1, __pyx_callargs+1-__pyx_t_3, 4+__pyx_t_3); __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0; __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 227, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; } __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; /* "astroscrappy/astroscrappy.pyx":230 * * # Subtract the input sky model, if applicable. * if inbkg is not None: # <<<<<<<<<<<<<< * cleanarr -= bkg * */ __pyx_t_7 = (__pyx_v_inbkg != Py_None); if (__pyx_t_7) { /* "astroscrappy/astroscrappy.pyx":231 * # Subtract the input sky model, if applicable. * if inbkg is not None: * cleanarr -= bkg # <<<<<<<<<<<<<< * * # Find the unmasked pixels to calculate the sky. */ if (unlikely(!__pyx_v_bkg)) { __Pyx_RaiseUnboundLocalError("bkg"); __PYX_ERR(0, 231, __pyx_L1_error) } __pyx_t_6 = PyNumber_InPlaceSubtract(__pyx_v_cleanarr, __pyx_v_bkg); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 231, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); __Pyx_DECREF_SET(__pyx_v_cleanarr, __pyx_t_6); __pyx_t_6 = 0; /* "astroscrappy/astroscrappy.pyx":230 * * # Subtract the input sky model, if applicable. * if inbkg is not None: # <<<<<<<<<<<<<< * cleanarr -= bkg * */ } /* "astroscrappy/astroscrappy.pyx":234 * * # Find the unmasked pixels to calculate the sky. * gooddata = np.zeros(int(nx * ny - np.asarray(mask).sum()), dtype=np.float32, # <<<<<<<<<<<<<< * order='c') * */ __Pyx_GetModuleGlobalName(__pyx_t_6, __pyx_n_s_np); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 234, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_t_6, __pyx_n_s_zeros); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 234, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; __pyx_t_6 = __Pyx_PyInt_From_int((__pyx_v_nx * __pyx_v_ny)); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 234, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_np); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 234, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_t_2, __pyx_n_s_asarray); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 234, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_5); __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; __pyx_t_2 = NULL; __pyx_t_3 = 0; #if CYTHON_UNPACK_METHODS if (unlikely(PyMethod_Check(__pyx_t_5))) { __pyx_t_2 = PyMethod_GET_SELF(__pyx_t_5); if (likely(__pyx_t_2)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_5); __Pyx_INCREF(__pyx_t_2); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_5, function); __pyx_t_3 = 1; } } #endif { PyObject *__pyx_callargs[2] = {__pyx_t_2, __pyx_v_mask}; __pyx_t_4 = __Pyx_PyObject_FastCall(__pyx_t_5, __pyx_callargs+1-__pyx_t_3, 1+__pyx_t_3); __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0; if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 234, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; } __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_t_4, __pyx_n_s_sum); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 234, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_5); __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __pyx_t_4 = NULL; __pyx_t_3 = 0; #if CYTHON_UNPACK_METHODS if (likely(PyMethod_Check(__pyx_t_5))) { __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_5); if (likely(__pyx_t_4)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_5); __Pyx_INCREF(__pyx_t_4); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_5, function); __pyx_t_3 = 1; } } #endif { PyObject *__pyx_callargs[2] = {__pyx_t_4, NULL}; __pyx_t_9 = __Pyx_PyObject_FastCall(__pyx_t_5, __pyx_callargs+1-__pyx_t_3, 0+__pyx_t_3); __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 234, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_9); __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; } __pyx_t_5 = PyNumber_Subtract(__pyx_t_6, __pyx_t_9); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 234, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_5); __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; __pyx_t_9 = __Pyx_PyNumber_Int(__pyx_t_5); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 234, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_9); __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; __pyx_t_5 = PyTuple_New(1); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 234, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_5); __Pyx_GIVEREF(__pyx_t_9); if (__Pyx_PyTuple_SET_ITEM(__pyx_t_5, 0, __pyx_t_9)) __PYX_ERR(0, 234, __pyx_L1_error); __pyx_t_9 = 0; __pyx_t_9 = __Pyx_PyDict_NewPresized(2); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 234, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_9); __Pyx_GetModuleGlobalName(__pyx_t_6, __pyx_n_s_np); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 234, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_t_6, __pyx_n_s_float32); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 234, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; if (PyDict_SetItem(__pyx_t_9, __pyx_n_s_dtype, __pyx_t_4) < 0) __PYX_ERR(0, 234, __pyx_L1_error) __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; if (PyDict_SetItem(__pyx_t_9, __pyx_n_s_order, __pyx_n_u_c) < 0) __PYX_ERR(0, 234, __pyx_L1_error) __pyx_t_4 = __Pyx_PyObject_Call(__pyx_t_1, __pyx_t_5, __pyx_t_9); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 234, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; __pyx_v_gooddata = __pyx_t_4; __pyx_t_4 = 0; /* "astroscrappy/astroscrappy.pyx":237 * order='c') * * igoodpix = 0 # <<<<<<<<<<<<<< * * gooddata[:] = cleanarr[np.logical_not(mask)] */ __pyx_v_igoodpix = 0; /* "astroscrappy/astroscrappy.pyx":239 * igoodpix = 0 * * gooddata[:] = cleanarr[np.logical_not(mask)] # <<<<<<<<<<<<<< * * # Get the default background level for large cosmic rays. */ __Pyx_GetModuleGlobalName(__pyx_t_9, __pyx_n_s_np); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 239, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_9); __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_t_9, __pyx_n_s_logical_not); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 239, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_5); __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; __pyx_t_9 = NULL; __pyx_t_3 = 0; #if CYTHON_UNPACK_METHODS if (unlikely(PyMethod_Check(__pyx_t_5))) { __pyx_t_9 = PyMethod_GET_SELF(__pyx_t_5); if (likely(__pyx_t_9)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_5); __Pyx_INCREF(__pyx_t_9); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_5, function); __pyx_t_3 = 1; } } #endif { PyObject *__pyx_callargs[2] = {__pyx_t_9, __pyx_v_mask}; __pyx_t_4 = __Pyx_PyObject_FastCall(__pyx_t_5, __pyx_callargs+1-__pyx_t_3, 1+__pyx_t_3); __Pyx_XDECREF(__pyx_t_9); __pyx_t_9 = 0; if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 239, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; } __pyx_t_5 = __Pyx_PyObject_GetItem(__pyx_v_cleanarr, __pyx_t_4); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 239, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_5); __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; if (__Pyx_PyObject_SetSlice(__pyx_v_gooddata, __pyx_t_5, 0, 0, NULL, NULL, &__pyx_slice__5, 0, 0, 0) < 0) __PYX_ERR(0, 239, __pyx_L1_error) __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; /* "astroscrappy/astroscrappy.pyx":242 * * # Get the default background level for large cosmic rays. * background_level = median(gooddata, len(gooddata)) # <<<<<<<<<<<<<< * goodvar = np.empty_like(gooddata, order='c') * goodvar[:] = clean_var[np.logical_not(mask)] */ __Pyx_GetModuleGlobalName(__pyx_t_4, __pyx_n_s_median); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 242, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __pyx_t_10 = PyObject_Length(__pyx_v_gooddata); if (unlikely(__pyx_t_10 == ((Py_ssize_t)-1))) __PYX_ERR(0, 242, __pyx_L1_error) __pyx_t_9 = PyInt_FromSsize_t(__pyx_t_10); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 242, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_9); __pyx_t_1 = NULL; __pyx_t_3 = 0; #if CYTHON_UNPACK_METHODS if (unlikely(PyMethod_Check(__pyx_t_4))) { __pyx_t_1 = PyMethod_GET_SELF(__pyx_t_4); if (likely(__pyx_t_1)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_4); __Pyx_INCREF(__pyx_t_1); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_4, function); __pyx_t_3 = 1; } } #endif { PyObject *__pyx_callargs[3] = {__pyx_t_1, __pyx_v_gooddata, __pyx_t_9}; __pyx_t_5 = __Pyx_PyObject_FastCall(__pyx_t_4, __pyx_callargs+1-__pyx_t_3, 2+__pyx_t_3); __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0; __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 242, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_5); __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; } __pyx_v_background_level = __pyx_t_5; __pyx_t_5 = 0; /* "astroscrappy/astroscrappy.pyx":243 * # Get the default background level for large cosmic rays. * background_level = median(gooddata, len(gooddata)) * goodvar = np.empty_like(gooddata, order='c') # <<<<<<<<<<<<<< * goodvar[:] = clean_var[np.logical_not(mask)] * background_var_level = median(goodvar, len(goodvar)) */ __Pyx_GetModuleGlobalName(__pyx_t_5, __pyx_n_s_np); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 243, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_5); __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_t_5, __pyx_n_s_empty_like); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 243, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; __pyx_t_5 = PyTuple_New(1); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 243, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_5); __Pyx_INCREF(__pyx_v_gooddata); __Pyx_GIVEREF(__pyx_v_gooddata); if (__Pyx_PyTuple_SET_ITEM(__pyx_t_5, 0, __pyx_v_gooddata)) __PYX_ERR(0, 243, __pyx_L1_error); __pyx_t_9 = __Pyx_PyDict_NewPresized(1); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 243, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_9); if (PyDict_SetItem(__pyx_t_9, __pyx_n_s_order, __pyx_n_u_c) < 0) __PYX_ERR(0, 243, __pyx_L1_error) __pyx_t_1 = __Pyx_PyObject_Call(__pyx_t_4, __pyx_t_5, __pyx_t_9); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 243, __pyx_L1_error) __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_9); __pyx_t_9 = 0; __pyx_v_goodvar = __pyx_t_1; __pyx_t_1 = 0; /* "astroscrappy/astroscrappy.pyx":244 * background_level = median(gooddata, len(gooddata)) * goodvar = np.empty_like(gooddata, order='c') * goodvar[:] = clean_var[np.logical_not(mask)] # <<<<<<<<<<<<<< * background_var_level = median(goodvar, len(goodvar)) * del goodvar */ __Pyx_GetModuleGlobalName(__pyx_t_9, __pyx_n_s_np); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 244, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_9); __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_t_9, __pyx_n_s_logical_not); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 244, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_5); __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; __pyx_t_9 = NULL; __pyx_t_3 = 0; #if CYTHON_UNPACK_METHODS if (unlikely(PyMethod_Check(__pyx_t_5))) { __pyx_t_9 = PyMethod_GET_SELF(__pyx_t_5); if (likely(__pyx_t_9)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_5); __Pyx_INCREF(__pyx_t_9); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_5, function); __pyx_t_3 = 1; } } #endif { PyObject *__pyx_callargs[2] = {__pyx_t_9, __pyx_v_mask}; __pyx_t_1 = __Pyx_PyObject_FastCall(__pyx_t_5, __pyx_callargs+1-__pyx_t_3, 1+__pyx_t_3); __Pyx_XDECREF(__pyx_t_9); __pyx_t_9 = 0; if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 244, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; } __pyx_t_5 = __Pyx_PyObject_GetItem(__pyx_v_clean_var, __pyx_t_1); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 244, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_5); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; if (__Pyx_PyObject_SetSlice(__pyx_v_goodvar, __pyx_t_5, 0, 0, NULL, NULL, &__pyx_slice__5, 0, 0, 0) < 0) __PYX_ERR(0, 244, __pyx_L1_error) __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; /* "astroscrappy/astroscrappy.pyx":245 * goodvar = np.empty_like(gooddata, order='c') * goodvar[:] = clean_var[np.logical_not(mask)] * background_var_level = median(goodvar, len(goodvar)) # <<<<<<<<<<<<<< * del goodvar * del gooddata */ __Pyx_GetModuleGlobalName(__pyx_t_1, __pyx_n_s_median); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 245, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_t_10 = PyObject_Length(__pyx_v_goodvar); if (unlikely(__pyx_t_10 == ((Py_ssize_t)-1))) __PYX_ERR(0, 245, __pyx_L1_error) __pyx_t_9 = PyInt_FromSsize_t(__pyx_t_10); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 245, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_9); __pyx_t_4 = NULL; __pyx_t_3 = 0; #if CYTHON_UNPACK_METHODS if (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 = 1; } } #endif { PyObject *__pyx_callargs[3] = {__pyx_t_4, __pyx_v_goodvar, __pyx_t_9}; __pyx_t_5 = __Pyx_PyObject_FastCall(__pyx_t_1, __pyx_callargs+1-__pyx_t_3, 2+__pyx_t_3); __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 245, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_5); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; } __pyx_v_background_var_level = __pyx_t_5; __pyx_t_5 = 0; /* "astroscrappy/astroscrappy.pyx":246 * goodvar[:] = clean_var[np.logical_not(mask)] * background_var_level = median(goodvar, len(goodvar)) * del goodvar # <<<<<<<<<<<<<< * del gooddata * */ __Pyx_DECREF(__pyx_v_goodvar); __pyx_v_goodvar = 0; /* "astroscrappy/astroscrappy.pyx":247 * background_var_level = median(goodvar, len(goodvar)) * del goodvar * del gooddata # <<<<<<<<<<<<<< * * # Set up the psf kernel if necessary. */ __Pyx_DECREF(__pyx_v_gooddata); __pyx_v_gooddata = 0; /* "astroscrappy/astroscrappy.pyx":250 * * # Set up the psf kernel if necessary. * if psfk is None and fsmode == 'convolve': # <<<<<<<<<<<<<< * # calculate the psf kernel psfk * if psfmodel == 'gauss': */ __pyx_t_8 = (__pyx_v_psfk == Py_None); if (__pyx_t_8) { } else { __pyx_t_7 = __pyx_t_8; goto __pyx_L14_bool_binop_done; } __pyx_t_8 = (__Pyx_PyUnicode_Equals(__pyx_v_fsmode, __pyx_n_u_convolve, Py_EQ)); if (unlikely((__pyx_t_8 < 0))) __PYX_ERR(0, 250, __pyx_L1_error) __pyx_t_7 = __pyx_t_8; __pyx_L14_bool_binop_done:; if (__pyx_t_7) { /* "astroscrappy/astroscrappy.pyx":252 * if psfk is None and fsmode == 'convolve': * # calculate the psf kernel psfk * if psfmodel == 'gauss': # <<<<<<<<<<<<<< * psfk = gausskernel(psffwhm, psfsize) * elif psfmodel == 'gaussx': */ __pyx_t_7 = (__Pyx_PyUnicode_Equals(__pyx_v_psfmodel, __pyx_n_u_gauss, Py_EQ)); if (unlikely((__pyx_t_7 < 0))) __PYX_ERR(0, 252, __pyx_L1_error) if (__pyx_t_7) { /* "astroscrappy/astroscrappy.pyx":253 * # calculate the psf kernel psfk * if psfmodel == 'gauss': * psfk = gausskernel(psffwhm, psfsize) # <<<<<<<<<<<<<< * elif psfmodel == 'gaussx': * psfk = gaussxkernel(psffwhm, psfsize) */ __Pyx_GetModuleGlobalName(__pyx_t_1, __pyx_n_s_gausskernel); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 253, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_t_9 = PyFloat_FromDouble(__pyx_v_psffwhm); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 253, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_9); __pyx_t_4 = __Pyx_PyInt_From_int(__pyx_v_psfsize); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 253, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __pyx_t_6 = NULL; __pyx_t_3 = 0; #if CYTHON_UNPACK_METHODS if (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_3 = 1; } } #endif { PyObject *__pyx_callargs[3] = {__pyx_t_6, __pyx_t_9, __pyx_t_4}; __pyx_t_5 = __Pyx_PyObject_FastCall(__pyx_t_1, __pyx_callargs+1-__pyx_t_3, 2+__pyx_t_3); __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0; __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 253, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_5); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; } __Pyx_DECREF_SET(__pyx_v_psfk, __pyx_t_5); __pyx_t_5 = 0; /* "astroscrappy/astroscrappy.pyx":252 * if psfk is None and fsmode == 'convolve': * # calculate the psf kernel psfk * if psfmodel == 'gauss': # <<<<<<<<<<<<<< * psfk = gausskernel(psffwhm, psfsize) * elif psfmodel == 'gaussx': */ goto __pyx_L16; } /* "astroscrappy/astroscrappy.pyx":254 * if psfmodel == 'gauss': * psfk = gausskernel(psffwhm, psfsize) * elif psfmodel == 'gaussx': # <<<<<<<<<<<<<< * psfk = gaussxkernel(psffwhm, psfsize) * elif psfmodel == 'gaussy': */ __pyx_t_7 = (__Pyx_PyUnicode_Equals(__pyx_v_psfmodel, __pyx_n_u_gaussx, Py_EQ)); if (unlikely((__pyx_t_7 < 0))) __PYX_ERR(0, 254, __pyx_L1_error) if (__pyx_t_7) { /* "astroscrappy/astroscrappy.pyx":255 * psfk = gausskernel(psffwhm, psfsize) * elif psfmodel == 'gaussx': * psfk = gaussxkernel(psffwhm, psfsize) # <<<<<<<<<<<<<< * elif psfmodel == 'gaussy': * psfk = gaussykernel(psffwhm, psfsize) */ __Pyx_GetModuleGlobalName(__pyx_t_1, __pyx_n_s_gaussxkernel); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 255, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_t_4 = PyFloat_FromDouble(__pyx_v_psffwhm); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 255, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __pyx_t_9 = __Pyx_PyInt_From_int(__pyx_v_psfsize); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 255, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_9); __pyx_t_6 = NULL; __pyx_t_3 = 0; #if CYTHON_UNPACK_METHODS if (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_3 = 1; } } #endif { PyObject *__pyx_callargs[3] = {__pyx_t_6, __pyx_t_4, __pyx_t_9}; __pyx_t_5 = __Pyx_PyObject_FastCall(__pyx_t_1, __pyx_callargs+1-__pyx_t_3, 2+__pyx_t_3); __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0; __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 255, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_5); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; } __Pyx_DECREF_SET(__pyx_v_psfk, __pyx_t_5); __pyx_t_5 = 0; /* "astroscrappy/astroscrappy.pyx":254 * if psfmodel == 'gauss': * psfk = gausskernel(psffwhm, psfsize) * elif psfmodel == 'gaussx': # <<<<<<<<<<<<<< * psfk = gaussxkernel(psffwhm, psfsize) * elif psfmodel == 'gaussy': */ goto __pyx_L16; } /* "astroscrappy/astroscrappy.pyx":256 * elif psfmodel == 'gaussx': * psfk = gaussxkernel(psffwhm, psfsize) * elif psfmodel == 'gaussy': # <<<<<<<<<<<<<< * psfk = gaussykernel(psffwhm, psfsize) * elif psfmodel == 'moffat': */ __pyx_t_7 = (__Pyx_PyUnicode_Equals(__pyx_v_psfmodel, __pyx_n_u_gaussy, Py_EQ)); if (unlikely((__pyx_t_7 < 0))) __PYX_ERR(0, 256, __pyx_L1_error) if (__pyx_t_7) { /* "astroscrappy/astroscrappy.pyx":257 * psfk = gaussxkernel(psffwhm, psfsize) * elif psfmodel == 'gaussy': * psfk = gaussykernel(psffwhm, psfsize) # <<<<<<<<<<<<<< * elif psfmodel == 'moffat': * psfk = moffatkernel(psffwhm, psfbeta, psfsize) */ __Pyx_GetModuleGlobalName(__pyx_t_1, __pyx_n_s_gaussykernel); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 257, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_t_9 = PyFloat_FromDouble(__pyx_v_psffwhm); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 257, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_9); __pyx_t_4 = __Pyx_PyInt_From_int(__pyx_v_psfsize); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 257, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __pyx_t_6 = NULL; __pyx_t_3 = 0; #if CYTHON_UNPACK_METHODS if (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_3 = 1; } } #endif { PyObject *__pyx_callargs[3] = {__pyx_t_6, __pyx_t_9, __pyx_t_4}; __pyx_t_5 = __Pyx_PyObject_FastCall(__pyx_t_1, __pyx_callargs+1-__pyx_t_3, 2+__pyx_t_3); __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0; __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 257, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_5); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; } __Pyx_DECREF_SET(__pyx_v_psfk, __pyx_t_5); __pyx_t_5 = 0; /* "astroscrappy/astroscrappy.pyx":256 * elif psfmodel == 'gaussx': * psfk = gaussxkernel(psffwhm, psfsize) * elif psfmodel == 'gaussy': # <<<<<<<<<<<<<< * psfk = gaussykernel(psffwhm, psfsize) * elif psfmodel == 'moffat': */ goto __pyx_L16; } /* "astroscrappy/astroscrappy.pyx":258 * elif psfmodel == 'gaussy': * psfk = gaussykernel(psffwhm, psfsize) * elif psfmodel == 'moffat': # <<<<<<<<<<<<<< * psfk = moffatkernel(psffwhm, psfbeta, psfsize) * else: */ __pyx_t_7 = (__Pyx_PyUnicode_Equals(__pyx_v_psfmodel, __pyx_n_u_moffat, Py_EQ)); if (unlikely((__pyx_t_7 < 0))) __PYX_ERR(0, 258, __pyx_L1_error) if (likely(__pyx_t_7)) { /* "astroscrappy/astroscrappy.pyx":259 * psfk = gaussykernel(psffwhm, psfsize) * elif psfmodel == 'moffat': * psfk = moffatkernel(psffwhm, psfbeta, psfsize) # <<<<<<<<<<<<<< * else: * raise ValueError('Please choose a supported PSF model.') */ __pyx_t_5 = __pyx_f_12astroscrappy_12astroscrappy_moffatkernel(__pyx_v_psffwhm, __pyx_v_psfbeta, __pyx_v_psfsize); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 259, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_5); __Pyx_DECREF_SET(__pyx_v_psfk, __pyx_t_5); __pyx_t_5 = 0; /* "astroscrappy/astroscrappy.pyx":258 * elif psfmodel == 'gaussy': * psfk = gaussykernel(psffwhm, psfsize) * elif psfmodel == 'moffat': # <<<<<<<<<<<<<< * psfk = moffatkernel(psffwhm, psfbeta, psfsize) * else: */ goto __pyx_L16; } /* "astroscrappy/astroscrappy.pyx":261 * psfk = moffatkernel(psffwhm, psfbeta, psfsize) * else: * raise ValueError('Please choose a supported PSF model.') # <<<<<<<<<<<<<< * # Reverse the psf kernel as that is what we use in the convolution throughout * psfk[:, :] = psfk[::-1, ::-1] */ /*else*/ { __pyx_t_5 = __Pyx_PyObject_Call(__pyx_builtin_ValueError, __pyx_tuple__12, NULL); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 261, __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(0, 261, __pyx_L1_error) } __pyx_L16:; /* "astroscrappy/astroscrappy.pyx":263 * raise ValueError('Please choose a supported PSF model.') * # Reverse the psf kernel as that is what we use in the convolution throughout * psfk[:, :] = psfk[::-1, ::-1] # <<<<<<<<<<<<<< * * # Define a cosmic ray mask */ __pyx_t_5 = __Pyx_PyObject_GetItem(__pyx_v_psfk, __pyx_tuple__14); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 263, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_5); if (unlikely((PyObject_SetItem(__pyx_v_psfk, __pyx_tuple__11, __pyx_t_5) < 0))) __PYX_ERR(0, 263, __pyx_L1_error) __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; /* "astroscrappy/astroscrappy.pyx":250 * * # Set up the psf kernel if necessary. * if psfk is None and fsmode == 'convolve': # <<<<<<<<<<<<<< * # calculate the psf kernel psfk * if psfmodel == 'gauss': */ } /* "astroscrappy/astroscrappy.pyx":267 * # Define a cosmic ray mask * # This is what will be returned at the end * crmask = np.zeros((ny, nx), dtype=np.uint8, order='C') # <<<<<<<<<<<<<< * * # Calculate the detection limit for neighbor pixels */ __Pyx_GetModuleGlobalName(__pyx_t_5, __pyx_n_s_np); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 267, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_5); __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_t_5, __pyx_n_s_zeros); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 267, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; __pyx_t_5 = __Pyx_PyInt_From_int(__pyx_v_ny); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 267, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_5); __pyx_t_4 = __Pyx_PyInt_From_int(__pyx_v_nx); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 267, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __pyx_t_9 = PyTuple_New(2); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 267, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_9); __Pyx_GIVEREF(__pyx_t_5); if (__Pyx_PyTuple_SET_ITEM(__pyx_t_9, 0, __pyx_t_5)) __PYX_ERR(0, 267, __pyx_L1_error); __Pyx_GIVEREF(__pyx_t_4); if (__Pyx_PyTuple_SET_ITEM(__pyx_t_9, 1, __pyx_t_4)) __PYX_ERR(0, 267, __pyx_L1_error); __pyx_t_5 = 0; __pyx_t_4 = 0; __pyx_t_4 = PyTuple_New(1); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 267, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __Pyx_GIVEREF(__pyx_t_9); if (__Pyx_PyTuple_SET_ITEM(__pyx_t_4, 0, __pyx_t_9)) __PYX_ERR(0, 267, __pyx_L1_error); __pyx_t_9 = 0; __pyx_t_9 = __Pyx_PyDict_NewPresized(2); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 267, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_9); __Pyx_GetModuleGlobalName(__pyx_t_5, __pyx_n_s_np); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 267, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_5); __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_t_5, __pyx_n_s_uint8); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 267, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; if (PyDict_SetItem(__pyx_t_9, __pyx_n_s_dtype, __pyx_t_6) < 0) __PYX_ERR(0, 267, __pyx_L1_error) __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; if (PyDict_SetItem(__pyx_t_9, __pyx_n_s_order, __pyx_n_u_C) < 0) __PYX_ERR(0, 267, __pyx_L1_error) __pyx_t_6 = __Pyx_PyObject_Call(__pyx_t_1, __pyx_t_4, __pyx_t_9); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 267, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; __pyx_v_crmask = __pyx_t_6; __pyx_t_6 = 0; /* "astroscrappy/astroscrappy.pyx":270 * * # Calculate the detection limit for neighbor pixels * cdef float sigcliplow = sigfrac * sigclip # <<<<<<<<<<<<<< * * # Run lacosmic for up to maxiter iterations */ __pyx_v_sigcliplow = (__pyx_v_sigfrac * __pyx_v_sigclip); /* "astroscrappy/astroscrappy.pyx":274 * # Run lacosmic for up to maxiter iterations * # We stop if no more cosmic ray pixels are found (quite rare) * if verbose: # <<<<<<<<<<<<<< * print("Starting {} L.A.Cosmic iterations".format(niter)) * for i in range(niter): */ __pyx_t_7 = __Pyx_PyObject_IsTrue(__pyx_v_verbose); if (unlikely((__pyx_t_7 < 0))) __PYX_ERR(0, 274, __pyx_L1_error) if (__pyx_t_7) { /* "astroscrappy/astroscrappy.pyx":275 * # We stop if no more cosmic ray pixels are found (quite rare) * if verbose: * print("Starting {} L.A.Cosmic iterations".format(niter)) # <<<<<<<<<<<<<< * for i in range(niter): * if verbose: */ __pyx_t_9 = __Pyx_PyObject_GetAttrStr(__pyx_kp_u_Starting_L_A_Cosmic_iterations, __pyx_n_s_format); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 275, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_9); __pyx_t_4 = __Pyx_PyInt_From_int(__pyx_v_niter); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 275, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __pyx_t_1 = NULL; __pyx_t_3 = 0; #if CYTHON_UNPACK_METHODS if (likely(PyMethod_Check(__pyx_t_9))) { __pyx_t_1 = PyMethod_GET_SELF(__pyx_t_9); if (likely(__pyx_t_1)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_9); __Pyx_INCREF(__pyx_t_1); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_9, function); __pyx_t_3 = 1; } } #endif { PyObject *__pyx_callargs[2] = {__pyx_t_1, __pyx_t_4}; __pyx_t_6 = __Pyx_PyObject_FastCall(__pyx_t_9, __pyx_callargs+1-__pyx_t_3, 1+__pyx_t_3); __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0; __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 275, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; } __pyx_t_9 = __Pyx_PyObject_CallOneArg(__pyx_builtin_print, __pyx_t_6); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 275, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_9); __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; /* "astroscrappy/astroscrappy.pyx":274 * # Run lacosmic for up to maxiter iterations * # We stop if no more cosmic ray pixels are found (quite rare) * if verbose: # <<<<<<<<<<<<<< * print("Starting {} L.A.Cosmic iterations".format(niter)) * for i in range(niter): */ } /* "astroscrappy/astroscrappy.pyx":276 * if verbose: * print("Starting {} L.A.Cosmic iterations".format(niter)) * for i in range(niter): # <<<<<<<<<<<<<< * if verbose: * print("Iteration {}:".format(i + 1)) */ __pyx_t_3 = __pyx_v_niter; __pyx_t_11 = __pyx_t_3; for (__pyx_t_12 = 0; __pyx_t_12 < __pyx_t_11; __pyx_t_12+=1) { __pyx_v_i = __pyx_t_12; /* "astroscrappy/astroscrappy.pyx":277 * print("Starting {} L.A.Cosmic iterations".format(niter)) * for i in range(niter): * if verbose: # <<<<<<<<<<<<<< * print("Iteration {}:".format(i + 1)) * */ __pyx_t_7 = __Pyx_PyObject_IsTrue(__pyx_v_verbose); if (unlikely((__pyx_t_7 < 0))) __PYX_ERR(0, 277, __pyx_L1_error) if (__pyx_t_7) { /* "astroscrappy/astroscrappy.pyx":278 * for i in range(niter): * if verbose: * print("Iteration {}:".format(i + 1)) # <<<<<<<<<<<<<< * * # Detect the cosmic rays */ __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_kp_u_Iteration, __pyx_n_s_format); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 278, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); __pyx_t_4 = __Pyx_PyInt_From_long((__pyx_v_i + 1)); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 278, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __pyx_t_1 = NULL; __pyx_t_13 = 0; #if CYTHON_UNPACK_METHODS if (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_13 = 1; } } #endif { PyObject *__pyx_callargs[2] = {__pyx_t_1, __pyx_t_4}; __pyx_t_9 = __Pyx_PyObject_FastCall(__pyx_t_6, __pyx_callargs+1-__pyx_t_13, 1+__pyx_t_13); __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0; __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 278, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_9); __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; } __pyx_t_6 = __Pyx_PyObject_CallOneArg(__pyx_builtin_print, __pyx_t_9); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 278, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; /* "astroscrappy/astroscrappy.pyx":277 * print("Starting {} L.A.Cosmic iterations".format(niter)) * for i in range(niter): * if verbose: # <<<<<<<<<<<<<< * print("Iteration {}:".format(i + 1)) * */ } /* "astroscrappy/astroscrappy.pyx":284 * # We subsample, convolve, clip negative values, * # and rebin to original size * subsam = subsample(cleanarr) # <<<<<<<<<<<<<< * * conved = laplaceconvolve(subsam) */ __Pyx_GetModuleGlobalName(__pyx_t_9, __pyx_n_s_subsample); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 284, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_9); __pyx_t_4 = NULL; __pyx_t_13 = 0; #if CYTHON_UNPACK_METHODS if (unlikely(PyMethod_Check(__pyx_t_9))) { __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_9); if (likely(__pyx_t_4)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_9); __Pyx_INCREF(__pyx_t_4); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_9, function); __pyx_t_13 = 1; } } #endif { PyObject *__pyx_callargs[2] = {__pyx_t_4, __pyx_v_cleanarr}; __pyx_t_6 = __Pyx_PyObject_FastCall(__pyx_t_9, __pyx_callargs+1-__pyx_t_13, 1+__pyx_t_13); __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 284, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; } __pyx_v_subsam = __pyx_t_6; __pyx_t_6 = 0; /* "astroscrappy/astroscrappy.pyx":286 * subsam = subsample(cleanarr) * * conved = laplaceconvolve(subsam) # <<<<<<<<<<<<<< * del subsam * */ __Pyx_GetModuleGlobalName(__pyx_t_9, __pyx_n_s_laplaceconvolve); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 286, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_9); __pyx_t_4 = NULL; __pyx_t_13 = 0; #if CYTHON_UNPACK_METHODS if (unlikely(PyMethod_Check(__pyx_t_9))) { __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_9); if (likely(__pyx_t_4)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_9); __Pyx_INCREF(__pyx_t_4); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_9, function); __pyx_t_13 = 1; } } #endif { PyObject *__pyx_callargs[2] = {__pyx_t_4, __pyx_v_subsam}; __pyx_t_6 = __Pyx_PyObject_FastCall(__pyx_t_9, __pyx_callargs+1-__pyx_t_13, 1+__pyx_t_13); __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 286, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; } __pyx_v_conved = __pyx_t_6; __pyx_t_6 = 0; /* "astroscrappy/astroscrappy.pyx":287 * * conved = laplaceconvolve(subsam) * del subsam # <<<<<<<<<<<<<< * * conved[conved < 0] = 0.0 */ __Pyx_DECREF(__pyx_v_subsam); __pyx_v_subsam = 0; /* "astroscrappy/astroscrappy.pyx":289 * del subsam * * conved[conved < 0] = 0.0 # <<<<<<<<<<<<<< * # This is called L+ in the original LA Cosmic/cosmics.py * s = rebin(conved) */ __pyx_t_6 = PyObject_RichCompare(__pyx_v_conved, __pyx_int_0, Py_LT); __Pyx_XGOTREF(__pyx_t_6); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 289, __pyx_L1_error) if (unlikely((PyObject_SetItem(__pyx_v_conved, __pyx_t_6, __pyx_float_0_0) < 0))) __PYX_ERR(0, 289, __pyx_L1_error) __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; /* "astroscrappy/astroscrappy.pyx":291 * conved[conved < 0] = 0.0 * # This is called L+ in the original LA Cosmic/cosmics.py * s = rebin(conved) # <<<<<<<<<<<<<< * del conved * */ __Pyx_GetModuleGlobalName(__pyx_t_9, __pyx_n_s_rebin); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 291, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_9); __pyx_t_4 = NULL; __pyx_t_13 = 0; #if CYTHON_UNPACK_METHODS if (unlikely(PyMethod_Check(__pyx_t_9))) { __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_9); if (likely(__pyx_t_4)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_9); __Pyx_INCREF(__pyx_t_4); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_9, function); __pyx_t_13 = 1; } } #endif { PyObject *__pyx_callargs[2] = {__pyx_t_4, __pyx_v_conved}; __pyx_t_6 = __Pyx_PyObject_FastCall(__pyx_t_9, __pyx_callargs+1-__pyx_t_13, 1+__pyx_t_13); __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 291, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; } __pyx_v_s = __pyx_t_6; __pyx_t_6 = 0; /* "astroscrappy/astroscrappy.pyx":292 * # This is called L+ in the original LA Cosmic/cosmics.py * s = rebin(conved) * del conved # <<<<<<<<<<<<<< * * # Build a noise map, to compare the laplacian to, based on the input */ __Pyx_DECREF(__pyx_v_conved); __pyx_v_conved = 0; /* "astroscrappy/astroscrappy.pyx":299 * # noise in a pixel *should* be, rather than what it actually is after * # a cosmic ray hit. * if sepmed: # <<<<<<<<<<<<<< * m5 = sepmedfilt7(clean_var) * else: */ __pyx_t_7 = __Pyx_PyObject_IsTrue(__pyx_v_sepmed); if (unlikely((__pyx_t_7 < 0))) __PYX_ERR(0, 299, __pyx_L1_error) if (__pyx_t_7) { /* "astroscrappy/astroscrappy.pyx":300 * # a cosmic ray hit. * if sepmed: * m5 = sepmedfilt7(clean_var) # <<<<<<<<<<<<<< * else: * m5 = medfilt5(clean_var) */ __Pyx_GetModuleGlobalName(__pyx_t_9, __pyx_n_s_sepmedfilt7); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 300, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_9); __pyx_t_4 = NULL; __pyx_t_13 = 0; #if CYTHON_UNPACK_METHODS if (unlikely(PyMethod_Check(__pyx_t_9))) { __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_9); if (likely(__pyx_t_4)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_9); __Pyx_INCREF(__pyx_t_4); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_9, function); __pyx_t_13 = 1; } } #endif { PyObject *__pyx_callargs[2] = {__pyx_t_4, __pyx_v_clean_var}; __pyx_t_6 = __Pyx_PyObject_FastCall(__pyx_t_9, __pyx_callargs+1-__pyx_t_13, 1+__pyx_t_13); __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 300, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; } __pyx_v_m5 = __pyx_t_6; __pyx_t_6 = 0; /* "astroscrappy/astroscrappy.pyx":299 * # noise in a pixel *should* be, rather than what it actually is after * # a cosmic ray hit. * if sepmed: # <<<<<<<<<<<<<< * m5 = sepmedfilt7(clean_var) * else: */ goto __pyx_L21; } /* "astroscrappy/astroscrappy.pyx":302 * m5 = sepmedfilt7(clean_var) * else: * m5 = medfilt5(clean_var) # <<<<<<<<<<<<<< * * # Here we add back in the background to get the full variance. m5 here is effectively the CR free variance */ /*else*/ { __Pyx_GetModuleGlobalName(__pyx_t_9, __pyx_n_s_medfilt5); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 302, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_9); __pyx_t_4 = NULL; __pyx_t_13 = 0; #if CYTHON_UNPACK_METHODS if (unlikely(PyMethod_Check(__pyx_t_9))) { __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_9); if (likely(__pyx_t_4)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_9); __Pyx_INCREF(__pyx_t_4); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_9, function); __pyx_t_13 = 1; } } #endif { PyObject *__pyx_callargs[2] = {__pyx_t_4, __pyx_v_clean_var}; __pyx_t_6 = __Pyx_PyObject_FastCall(__pyx_t_9, __pyx_callargs+1-__pyx_t_13, 1+__pyx_t_13); __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 302, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; } __pyx_v_m5 = __pyx_t_6; __pyx_t_6 = 0; } __pyx_L21:; /* "astroscrappy/astroscrappy.pyx":305 * * # Here we add back in the background to get the full variance. m5 here is effectively the CR free variance * if inbkg is not None: # <<<<<<<<<<<<<< * m5 += bkg * # Clip noise so that we can take a square root */ __pyx_t_7 = (__pyx_v_inbkg != Py_None); if (__pyx_t_7) { /* "astroscrappy/astroscrappy.pyx":306 * # Here we add back in the background to get the full variance. m5 here is effectively the CR free variance * if inbkg is not None: * m5 += bkg # <<<<<<<<<<<<<< * # Clip noise so that we can take a square root * m5[m5 < 0.00001] = 0.00001 */ if (unlikely(!__pyx_v_bkg)) { __Pyx_RaiseUnboundLocalError("bkg"); __PYX_ERR(0, 306, __pyx_L1_error) } __pyx_t_6 = PyNumber_InPlaceAdd(__pyx_v_m5, __pyx_v_bkg); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 306, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); __Pyx_DECREF_SET(__pyx_v_m5, __pyx_t_6); __pyx_t_6 = 0; /* "astroscrappy/astroscrappy.pyx":305 * * # Here we add back in the background to get the full variance. m5 here is effectively the CR free variance * if inbkg is not None: # <<<<<<<<<<<<<< * m5 += bkg * # Clip noise so that we can take a square root */ } /* "astroscrappy/astroscrappy.pyx":308 * m5 += bkg * # Clip noise so that we can take a square root * m5[m5 < 0.00001] = 0.00001 # <<<<<<<<<<<<<< * noise = np.sqrt(m5) * del m5 */ __pyx_t_6 = PyObject_RichCompare(__pyx_v_m5, __pyx_float_0_00001, Py_LT); __Pyx_XGOTREF(__pyx_t_6); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 308, __pyx_L1_error) if (unlikely((PyObject_SetItem(__pyx_v_m5, __pyx_t_6, __pyx_float_0_00001) < 0))) __PYX_ERR(0, 308, __pyx_L1_error) __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; /* "astroscrappy/astroscrappy.pyx":309 * # Clip noise so that we can take a square root * m5[m5 < 0.00001] = 0.00001 * noise = np.sqrt(m5) # <<<<<<<<<<<<<< * del m5 * */ __Pyx_GetModuleGlobalName(__pyx_t_9, __pyx_n_s_np); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 309, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_9); __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_t_9, __pyx_n_s_sqrt); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 309, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; __pyx_t_9 = NULL; __pyx_t_13 = 0; #if CYTHON_UNPACK_METHODS if (unlikely(PyMethod_Check(__pyx_t_4))) { __pyx_t_9 = PyMethod_GET_SELF(__pyx_t_4); if (likely(__pyx_t_9)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_4); __Pyx_INCREF(__pyx_t_9); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_4, function); __pyx_t_13 = 1; } } #endif { PyObject *__pyx_callargs[2] = {__pyx_t_9, __pyx_v_m5}; __pyx_t_6 = __Pyx_PyObject_FastCall(__pyx_t_4, __pyx_callargs+1-__pyx_t_13, 1+__pyx_t_13); __Pyx_XDECREF(__pyx_t_9); __pyx_t_9 = 0; if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 309, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; } __pyx_v_noise = __pyx_t_6; __pyx_t_6 = 0; /* "astroscrappy/astroscrappy.pyx":310 * m5[m5 < 0.00001] = 0.00001 * noise = np.sqrt(m5) * del m5 # <<<<<<<<<<<<<< * * # Laplacian signal to noise ratio : */ __Pyx_DECREF(__pyx_v_m5); __pyx_v_m5 = 0; /* "astroscrappy/astroscrappy.pyx":313 * * # Laplacian signal to noise ratio : * s /= 2.0 * noise # <<<<<<<<<<<<<< * # the 2.0 is from the 2x2 subsampling and is denoted f_s in the original paper * # This s is called sigmap in the original lacosmic.cl */ __pyx_t_6 = PyNumber_Multiply(__pyx_float_2_0, __pyx_v_noise); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 313, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); __pyx_t_4 = __Pyx_PyNumber_InPlaceDivide(__pyx_v_s, __pyx_t_6); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 313, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; __Pyx_DECREF_SET(__pyx_v_s, __pyx_t_4); __pyx_t_4 = 0; /* "astroscrappy/astroscrappy.pyx":317 * # This s is called sigmap in the original lacosmic.cl * * if sepmed: # <<<<<<<<<<<<<< * sp = sepmedfilt7(s) * else: */ __pyx_t_7 = __Pyx_PyObject_IsTrue(__pyx_v_sepmed); if (unlikely((__pyx_t_7 < 0))) __PYX_ERR(0, 317, __pyx_L1_error) if (__pyx_t_7) { /* "astroscrappy/astroscrappy.pyx":318 * * if sepmed: * sp = sepmedfilt7(s) # <<<<<<<<<<<<<< * else: * sp = medfilt5(s) */ __Pyx_GetModuleGlobalName(__pyx_t_6, __pyx_n_s_sepmedfilt7); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 318, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); __pyx_t_9 = NULL; __pyx_t_13 = 0; #if CYTHON_UNPACK_METHODS if (unlikely(PyMethod_Check(__pyx_t_6))) { __pyx_t_9 = PyMethod_GET_SELF(__pyx_t_6); if (likely(__pyx_t_9)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_6); __Pyx_INCREF(__pyx_t_9); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_6, function); __pyx_t_13 = 1; } } #endif { PyObject *__pyx_callargs[2] = {__pyx_t_9, __pyx_v_s}; __pyx_t_4 = __Pyx_PyObject_FastCall(__pyx_t_6, __pyx_callargs+1-__pyx_t_13, 1+__pyx_t_13); __Pyx_XDECREF(__pyx_t_9); __pyx_t_9 = 0; if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 318, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; } __pyx_v_sp = __pyx_t_4; __pyx_t_4 = 0; /* "astroscrappy/astroscrappy.pyx":317 * # This s is called sigmap in the original lacosmic.cl * * if sepmed: # <<<<<<<<<<<<<< * sp = sepmedfilt7(s) * else: */ goto __pyx_L23; } /* "astroscrappy/astroscrappy.pyx":320 * sp = sepmedfilt7(s) * else: * sp = medfilt5(s) # <<<<<<<<<<<<<< * * # Remove the large structures (s prime) : */ /*else*/ { __Pyx_GetModuleGlobalName(__pyx_t_6, __pyx_n_s_medfilt5); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 320, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); __pyx_t_9 = NULL; __pyx_t_13 = 0; #if CYTHON_UNPACK_METHODS if (unlikely(PyMethod_Check(__pyx_t_6))) { __pyx_t_9 = PyMethod_GET_SELF(__pyx_t_6); if (likely(__pyx_t_9)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_6); __Pyx_INCREF(__pyx_t_9); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_6, function); __pyx_t_13 = 1; } } #endif { PyObject *__pyx_callargs[2] = {__pyx_t_9, __pyx_v_s}; __pyx_t_4 = __Pyx_PyObject_FastCall(__pyx_t_6, __pyx_callargs+1-__pyx_t_13, 1+__pyx_t_13); __Pyx_XDECREF(__pyx_t_9); __pyx_t_9 = 0; if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 320, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; } __pyx_v_sp = __pyx_t_4; __pyx_t_4 = 0; } __pyx_L23:; /* "astroscrappy/astroscrappy.pyx":323 * * # Remove the large structures (s prime) : * sp = s - sp # <<<<<<<<<<<<<< * del s * */ __pyx_t_4 = PyNumber_Subtract(__pyx_v_s, __pyx_v_sp); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 323, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __Pyx_DECREF_SET(__pyx_v_sp, __pyx_t_4); __pyx_t_4 = 0; /* "astroscrappy/astroscrappy.pyx":324 * # Remove the large structures (s prime) : * sp = s - sp * del s # <<<<<<<<<<<<<< * * # Find the candidate cosmic rays */ __Pyx_DECREF(__pyx_v_s); __pyx_v_s = 0; /* "astroscrappy/astroscrappy.pyx":327 * * # Find the candidate cosmic rays * goodpix = np.logical_not(mask) # <<<<<<<<<<<<<< * cosmics = np.logical_and(sp > sigclip, goodpix) * */ __Pyx_GetModuleGlobalName(__pyx_t_6, __pyx_n_s_np); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 327, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); __pyx_t_9 = __Pyx_PyObject_GetAttrStr(__pyx_t_6, __pyx_n_s_logical_not); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 327, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_9); __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; __pyx_t_6 = NULL; __pyx_t_13 = 0; #if CYTHON_UNPACK_METHODS if (unlikely(PyMethod_Check(__pyx_t_9))) { __pyx_t_6 = PyMethod_GET_SELF(__pyx_t_9); if (likely(__pyx_t_6)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_9); __Pyx_INCREF(__pyx_t_6); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_9, function); __pyx_t_13 = 1; } } #endif { PyObject *__pyx_callargs[2] = {__pyx_t_6, __pyx_v_mask}; __pyx_t_4 = __Pyx_PyObject_FastCall(__pyx_t_9, __pyx_callargs+1-__pyx_t_13, 1+__pyx_t_13); __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0; if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 327, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; } __pyx_v_goodpix = __pyx_t_4; __pyx_t_4 = 0; /* "astroscrappy/astroscrappy.pyx":328 * # Find the candidate cosmic rays * goodpix = np.logical_not(mask) * cosmics = np.logical_and(sp > sigclip, goodpix) # <<<<<<<<<<<<<< * * # Build the fine structure image : */ __Pyx_GetModuleGlobalName(__pyx_t_9, __pyx_n_s_np); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 328, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_9); __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_t_9, __pyx_n_s_logical_and); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 328, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; __pyx_t_9 = PyFloat_FromDouble(__pyx_v_sigclip); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 328, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_9); __pyx_t_1 = PyObject_RichCompare(__pyx_v_sp, __pyx_t_9, Py_GT); __Pyx_XGOTREF(__pyx_t_1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 328, __pyx_L1_error) __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; __pyx_t_9 = NULL; __pyx_t_13 = 0; #if CYTHON_UNPACK_METHODS if (unlikely(PyMethod_Check(__pyx_t_6))) { __pyx_t_9 = PyMethod_GET_SELF(__pyx_t_6); if (likely(__pyx_t_9)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_6); __Pyx_INCREF(__pyx_t_9); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_6, function); __pyx_t_13 = 1; } } #endif { PyObject *__pyx_callargs[3] = {__pyx_t_9, __pyx_t_1, __pyx_v_goodpix}; __pyx_t_4 = __Pyx_PyObject_FastCall(__pyx_t_6, __pyx_callargs+1-__pyx_t_13, 2+__pyx_t_13); __Pyx_XDECREF(__pyx_t_9); __pyx_t_9 = 0; __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 328, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; } __pyx_v_cosmics = __pyx_t_4; __pyx_t_4 = 0; /* "astroscrappy/astroscrappy.pyx":333 * # TODO: we can gain a reasonable performance boost if we only calculate the fine structure stuff for cosmic * # pixels instead of the whole image * if fsmode == 'convolve': # <<<<<<<<<<<<<< * # Use a match filter, the (reversed) psf convolved with the image / variance * f = convolve(cleanarr / noise / noise, psfk) */ __pyx_t_7 = (__Pyx_PyUnicode_Equals(__pyx_v_fsmode, __pyx_n_u_convolve, Py_EQ)); if (unlikely((__pyx_t_7 < 0))) __PYX_ERR(0, 333, __pyx_L1_error) if (__pyx_t_7) { /* "astroscrappy/astroscrappy.pyx":335 * if fsmode == 'convolve': * # Use a match filter, the (reversed) psf convolved with the image / variance * f = convolve(cleanarr / noise / noise, psfk) # <<<<<<<<<<<<<< * # Normalize by the sum of the weights to get the flux of the source assuming it was actually a psf. * # This will pull the value of pixels that do not look like psfs (e.g. CRs) down. */ __Pyx_GetModuleGlobalName(__pyx_t_6, __pyx_n_s_convolve); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 335, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); __pyx_t_1 = __Pyx_PyNumber_Divide(__pyx_v_cleanarr, __pyx_v_noise); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 335, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_t_9 = __Pyx_PyNumber_Divide(__pyx_t_1, __pyx_v_noise); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 335, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_9); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __pyx_t_1 = NULL; __pyx_t_13 = 0; #if CYTHON_UNPACK_METHODS if (unlikely(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_13 = 1; } } #endif { PyObject *__pyx_callargs[3] = {__pyx_t_1, __pyx_t_9, __pyx_v_psfk}; __pyx_t_4 = __Pyx_PyObject_FastCall(__pyx_t_6, __pyx_callargs+1-__pyx_t_13, 2+__pyx_t_13); __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0; __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 335, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; } __pyx_v_f = __pyx_t_4; __pyx_t_4 = 0; /* "astroscrappy/astroscrappy.pyx":338 * # Normalize by the sum of the weights to get the flux of the source assuming it was actually a psf. * # This will pull the value of pixels that do not look like psfs (e.g. CRs) down. * f = f / convolve(1.0 / noise / noise, psfk) # <<<<<<<<<<<<<< * elif fsmode == 'median': * if sepmed: */ __Pyx_GetModuleGlobalName(__pyx_t_6, __pyx_n_s_convolve); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 338, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); __pyx_t_9 = __Pyx_PyFloat_TrueDivideCObj(__pyx_float_1_0, __pyx_v_noise, 1.0, 0, 1); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 338, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_9); __pyx_t_1 = __Pyx_PyNumber_Divide(__pyx_t_9, __pyx_v_noise); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 338, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; __pyx_t_9 = NULL; __pyx_t_13 = 0; #if CYTHON_UNPACK_METHODS if (unlikely(PyMethod_Check(__pyx_t_6))) { __pyx_t_9 = PyMethod_GET_SELF(__pyx_t_6); if (likely(__pyx_t_9)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_6); __Pyx_INCREF(__pyx_t_9); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_6, function); __pyx_t_13 = 1; } } #endif { PyObject *__pyx_callargs[3] = {__pyx_t_9, __pyx_t_1, __pyx_v_psfk}; __pyx_t_4 = __Pyx_PyObject_FastCall(__pyx_t_6, __pyx_callargs+1-__pyx_t_13, 2+__pyx_t_13); __Pyx_XDECREF(__pyx_t_9); __pyx_t_9 = 0; __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 338, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; } __pyx_t_6 = __Pyx_PyNumber_Divide(__pyx_v_f, __pyx_t_4); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 338, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __Pyx_DECREF_SET(__pyx_v_f, __pyx_t_6); __pyx_t_6 = 0; /* "astroscrappy/astroscrappy.pyx":333 * # TODO: we can gain a reasonable performance boost if we only calculate the fine structure stuff for cosmic * # pixels instead of the whole image * if fsmode == 'convolve': # <<<<<<<<<<<<<< * # Use a match filter, the (reversed) psf convolved with the image / variance * f = convolve(cleanarr / noise / noise, psfk) */ goto __pyx_L24; } /* "astroscrappy/astroscrappy.pyx":339 * # This will pull the value of pixels that do not look like psfs (e.g. CRs) down. * f = f / convolve(1.0 / noise / noise, psfk) * elif fsmode == 'median': # <<<<<<<<<<<<<< * if sepmed: * f = sepmedfilt5(cleanarr) */ __pyx_t_7 = (__Pyx_PyUnicode_Equals(__pyx_v_fsmode, __pyx_n_u_median, Py_EQ)); if (unlikely((__pyx_t_7 < 0))) __PYX_ERR(0, 339, __pyx_L1_error) if (likely(__pyx_t_7)) { /* "astroscrappy/astroscrappy.pyx":340 * f = f / convolve(1.0 / noise / noise, psfk) * elif fsmode == 'median': * if sepmed: # <<<<<<<<<<<<<< * f = sepmedfilt5(cleanarr) * else: */ __pyx_t_7 = __Pyx_PyObject_IsTrue(__pyx_v_sepmed); if (unlikely((__pyx_t_7 < 0))) __PYX_ERR(0, 340, __pyx_L1_error) if (__pyx_t_7) { /* "astroscrappy/astroscrappy.pyx":341 * elif fsmode == 'median': * if sepmed: * f = sepmedfilt5(cleanarr) # <<<<<<<<<<<<<< * else: * f = medfilt3(cleanarr) */ __Pyx_GetModuleGlobalName(__pyx_t_4, __pyx_n_s_sepmedfilt5); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 341, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __pyx_t_1 = NULL; __pyx_t_13 = 0; #if CYTHON_UNPACK_METHODS if (unlikely(PyMethod_Check(__pyx_t_4))) { __pyx_t_1 = PyMethod_GET_SELF(__pyx_t_4); if (likely(__pyx_t_1)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_4); __Pyx_INCREF(__pyx_t_1); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_4, function); __pyx_t_13 = 1; } } #endif { PyObject *__pyx_callargs[2] = {__pyx_t_1, __pyx_v_cleanarr}; __pyx_t_6 = __Pyx_PyObject_FastCall(__pyx_t_4, __pyx_callargs+1-__pyx_t_13, 1+__pyx_t_13); __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0; if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 341, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; } __pyx_v_f = __pyx_t_6; __pyx_t_6 = 0; /* "astroscrappy/astroscrappy.pyx":340 * f = f / convolve(1.0 / noise / noise, psfk) * elif fsmode == 'median': * if sepmed: # <<<<<<<<<<<<<< * f = sepmedfilt5(cleanarr) * else: */ goto __pyx_L25; } /* "astroscrappy/astroscrappy.pyx":343 * f = sepmedfilt5(cleanarr) * else: * f = medfilt3(cleanarr) # <<<<<<<<<<<<<< * else: * raise ValueError('Please choose a valid fine structure mode.') */ /*else*/ { __Pyx_GetModuleGlobalName(__pyx_t_4, __pyx_n_s_medfilt3); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 343, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __pyx_t_1 = NULL; __pyx_t_13 = 0; #if CYTHON_UNPACK_METHODS if (unlikely(PyMethod_Check(__pyx_t_4))) { __pyx_t_1 = PyMethod_GET_SELF(__pyx_t_4); if (likely(__pyx_t_1)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_4); __Pyx_INCREF(__pyx_t_1); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_4, function); __pyx_t_13 = 1; } } #endif { PyObject *__pyx_callargs[2] = {__pyx_t_1, __pyx_v_cleanarr}; __pyx_t_6 = __Pyx_PyObject_FastCall(__pyx_t_4, __pyx_callargs+1-__pyx_t_13, 1+__pyx_t_13); __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0; if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 343, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; } __pyx_v_f = __pyx_t_6; __pyx_t_6 = 0; } __pyx_L25:; /* "astroscrappy/astroscrappy.pyx":339 * # This will pull the value of pixels that do not look like psfs (e.g. CRs) down. * f = f / convolve(1.0 / noise / noise, psfk) * elif fsmode == 'median': # <<<<<<<<<<<<<< * if sepmed: * f = sepmedfilt5(cleanarr) */ goto __pyx_L24; } /* "astroscrappy/astroscrappy.pyx":345 * f = medfilt3(cleanarr) * else: * raise ValueError('Please choose a valid fine structure mode.') # <<<<<<<<<<<<<< * * if sepmed: */ /*else*/ { __pyx_t_6 = __Pyx_PyObject_Call(__pyx_builtin_ValueError, __pyx_tuple__15, NULL); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 345, __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, 345, __pyx_L1_error) } __pyx_L24:; /* "astroscrappy/astroscrappy.pyx":347 * raise ValueError('Please choose a valid fine structure mode.') * * if sepmed: # <<<<<<<<<<<<<< * m7 = sepmedfilt9(f) * else: */ __pyx_t_7 = __Pyx_PyObject_IsTrue(__pyx_v_sepmed); if (unlikely((__pyx_t_7 < 0))) __PYX_ERR(0, 347, __pyx_L1_error) if (__pyx_t_7) { /* "astroscrappy/astroscrappy.pyx":348 * * if sepmed: * m7 = sepmedfilt9(f) # <<<<<<<<<<<<<< * else: * m7 = medfilt7(f) */ __Pyx_GetModuleGlobalName(__pyx_t_4, __pyx_n_s_sepmedfilt9); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 348, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __pyx_t_1 = NULL; __pyx_t_13 = 0; #if CYTHON_UNPACK_METHODS if (unlikely(PyMethod_Check(__pyx_t_4))) { __pyx_t_1 = PyMethod_GET_SELF(__pyx_t_4); if (likely(__pyx_t_1)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_4); __Pyx_INCREF(__pyx_t_1); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_4, function); __pyx_t_13 = 1; } } #endif { PyObject *__pyx_callargs[2] = {__pyx_t_1, __pyx_v_f}; __pyx_t_6 = __Pyx_PyObject_FastCall(__pyx_t_4, __pyx_callargs+1-__pyx_t_13, 1+__pyx_t_13); __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0; if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 348, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; } __pyx_v_m7 = __pyx_t_6; __pyx_t_6 = 0; /* "astroscrappy/astroscrappy.pyx":347 * raise ValueError('Please choose a valid fine structure mode.') * * if sepmed: # <<<<<<<<<<<<<< * m7 = sepmedfilt9(f) * else: */ goto __pyx_L26; } /* "astroscrappy/astroscrappy.pyx":350 * m7 = sepmedfilt9(f) * else: * m7 = medfilt7(f) # <<<<<<<<<<<<<< * * # Note that original paper compares L+ / Fine Structure Image < threshold. */ /*else*/ { __Pyx_GetModuleGlobalName(__pyx_t_4, __pyx_n_s_medfilt7); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 350, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __pyx_t_1 = NULL; __pyx_t_13 = 0; #if CYTHON_UNPACK_METHODS if (unlikely(PyMethod_Check(__pyx_t_4))) { __pyx_t_1 = PyMethod_GET_SELF(__pyx_t_4); if (likely(__pyx_t_1)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_4); __Pyx_INCREF(__pyx_t_1); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_4, function); __pyx_t_13 = 1; } } #endif { PyObject *__pyx_callargs[2] = {__pyx_t_1, __pyx_v_f}; __pyx_t_6 = __Pyx_PyObject_FastCall(__pyx_t_4, __pyx_callargs+1-__pyx_t_13, 1+__pyx_t_13); __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0; if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 350, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; } __pyx_v_m7 = __pyx_t_6; __pyx_t_6 = 0; } __pyx_L26:; /* "astroscrappy/astroscrappy.pyx":355 * # The original code and therefore we compare S' / Fine Structure Image < threshold. * # As such, we scale the fine structure image by the noise here so it is in the same units as S'. * f = (f - m7) / noise # <<<<<<<<<<<<<< * # Clip f as we will divide by f. Similar to the IRAF version. * f[f < 0.01] = 0.01 */ __pyx_t_6 = PyNumber_Subtract(__pyx_v_f, __pyx_v_m7); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 355, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); __pyx_t_4 = __Pyx_PyNumber_Divide(__pyx_t_6, __pyx_v_noise); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 355, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; __Pyx_DECREF_SET(__pyx_v_f, __pyx_t_4); __pyx_t_4 = 0; /* "astroscrappy/astroscrappy.pyx":357 * f = (f - m7) / noise * # Clip f as we will divide by f. Similar to the IRAF version. * f[f < 0.01] = 0.01 # <<<<<<<<<<<<<< * * del m7 */ __pyx_t_4 = PyObject_RichCompare(__pyx_v_f, __pyx_float_0_01, Py_LT); __Pyx_XGOTREF(__pyx_t_4); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 357, __pyx_L1_error) if (unlikely((PyObject_SetItem(__pyx_v_f, __pyx_t_4, __pyx_float_0_01) < 0))) __PYX_ERR(0, 357, __pyx_L1_error) __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; /* "astroscrappy/astroscrappy.pyx":359 * f[f < 0.01] = 0.01 * * del m7 # <<<<<<<<<<<<<< * del noise * */ __Pyx_DECREF(__pyx_v_m7); __pyx_v_m7 = 0; /* "astroscrappy/astroscrappy.pyx":360 * * del m7 * del noise # <<<<<<<<<<<<<< * * # S' / F is still not exactly what is in the paper as we have subtracted the "sampling flux" from S */ __Pyx_DECREF(__pyx_v_noise); __pyx_v_noise = 0; /* "astroscrappy/astroscrappy.pyx":365 * # via the median filter. This should be an optimization because we have removed the smooth component * # and are therefore comparing the candidate "CR flux" only. * cosmics = np.logical_and(cosmics, (sp / f) > objlim) # <<<<<<<<<<<<<< * del f * */ __Pyx_GetModuleGlobalName(__pyx_t_6, __pyx_n_s_np); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 365, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_t_6, __pyx_n_s_logical_and); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 365, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; __pyx_t_6 = __Pyx_PyNumber_Divide(__pyx_v_sp, __pyx_v_f); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 365, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); __pyx_t_9 = PyFloat_FromDouble(__pyx_v_objlim); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 365, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_9); __pyx_t_5 = PyObject_RichCompare(__pyx_t_6, __pyx_t_9, Py_GT); __Pyx_XGOTREF(__pyx_t_5); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 365, __pyx_L1_error) __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; __pyx_t_9 = NULL; __pyx_t_13 = 0; #if CYTHON_UNPACK_METHODS if (unlikely(PyMethod_Check(__pyx_t_1))) { __pyx_t_9 = PyMethod_GET_SELF(__pyx_t_1); if (likely(__pyx_t_9)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_1); __Pyx_INCREF(__pyx_t_9); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_1, function); __pyx_t_13 = 1; } } #endif { PyObject *__pyx_callargs[3] = {__pyx_t_9, __pyx_v_cosmics, __pyx_t_5}; __pyx_t_4 = __Pyx_PyObject_FastCall(__pyx_t_1, __pyx_callargs+1-__pyx_t_13, 2+__pyx_t_13); __Pyx_XDECREF(__pyx_t_9); __pyx_t_9 = 0; __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 365, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; } __Pyx_DECREF_SET(__pyx_v_cosmics, __pyx_t_4); __pyx_t_4 = 0; /* "astroscrappy/astroscrappy.pyx":366 * # and are therefore comparing the candidate "CR flux" only. * cosmics = np.logical_and(cosmics, (sp / f) > objlim) * del f # <<<<<<<<<<<<<< * * # What follows is a special treatment for neighbors, with more relaxed */ __Pyx_DECREF(__pyx_v_f); __pyx_v_f = 0; /* "astroscrappy/astroscrappy.pyx":372 * # We grow these cosmics a first time to determine the immediate * # neighborhood. * cosmics = dilate3(cosmics) # <<<<<<<<<<<<<< * cosmics = np.logical_and(cosmics, goodpix) * # From this grown set, we keep those that have sp > sigmaclip */ __Pyx_GetModuleGlobalName(__pyx_t_1, __pyx_n_s_dilate3); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 372, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_t_5 = NULL; __pyx_t_13 = 0; #if CYTHON_UNPACK_METHODS if (unlikely(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_13 = 1; } } #endif { PyObject *__pyx_callargs[2] = {__pyx_t_5, __pyx_v_cosmics}; __pyx_t_4 = __Pyx_PyObject_FastCall(__pyx_t_1, __pyx_callargs+1-__pyx_t_13, 1+__pyx_t_13); __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0; if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 372, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; } __Pyx_DECREF_SET(__pyx_v_cosmics, __pyx_t_4); __pyx_t_4 = 0; /* "astroscrappy/astroscrappy.pyx":373 * # neighborhood. * cosmics = dilate3(cosmics) * cosmics = np.logical_and(cosmics, goodpix) # <<<<<<<<<<<<<< * # From this grown set, we keep those that have sp > sigmaclip * # Note that the only new pixels that should be added here are ones that were rejected by the */ __Pyx_GetModuleGlobalName(__pyx_t_1, __pyx_n_s_np); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 373, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_t_1, __pyx_n_s_logical_and); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 373, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_5); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __pyx_t_1 = NULL; __pyx_t_13 = 0; #if CYTHON_UNPACK_METHODS if (unlikely(PyMethod_Check(__pyx_t_5))) { __pyx_t_1 = PyMethod_GET_SELF(__pyx_t_5); if (likely(__pyx_t_1)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_5); __Pyx_INCREF(__pyx_t_1); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_5, function); __pyx_t_13 = 1; } } #endif { PyObject *__pyx_callargs[3] = {__pyx_t_1, __pyx_v_cosmics, __pyx_v_goodpix}; __pyx_t_4 = __Pyx_PyObject_FastCall(__pyx_t_5, __pyx_callargs+1-__pyx_t_13, 2+__pyx_t_13); __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0; if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 373, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; } __Pyx_DECREF_SET(__pyx_v_cosmics, __pyx_t_4); __pyx_t_4 = 0; /* "astroscrappy/astroscrappy.pyx":378 * # objlim test. As they are neighbors to true CRs, we take that as a prior that CR probability * # of the neighboring pixel is enhanced. * cosmics = np.logical_and(sp > sigclip, cosmics) # <<<<<<<<<<<<<< * * # Now we repeat this procedure, but lower the detection limit to siglow */ __Pyx_GetModuleGlobalName(__pyx_t_5, __pyx_n_s_np); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 378, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_5); __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_t_5, __pyx_n_s_logical_and); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 378, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; __pyx_t_5 = PyFloat_FromDouble(__pyx_v_sigclip); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 378, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_5); __pyx_t_9 = PyObject_RichCompare(__pyx_v_sp, __pyx_t_5, Py_GT); __Pyx_XGOTREF(__pyx_t_9); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 378, __pyx_L1_error) __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; __pyx_t_5 = NULL; __pyx_t_13 = 0; #if CYTHON_UNPACK_METHODS if (unlikely(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_13 = 1; } } #endif { PyObject *__pyx_callargs[3] = {__pyx_t_5, __pyx_t_9, __pyx_v_cosmics}; __pyx_t_4 = __Pyx_PyObject_FastCall(__pyx_t_1, __pyx_callargs+1-__pyx_t_13, 2+__pyx_t_13); __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0; __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 378, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; } __Pyx_DECREF_SET(__pyx_v_cosmics, __pyx_t_4); __pyx_t_4 = 0; /* "astroscrappy/astroscrappy.pyx":381 * * # Now we repeat this procedure, but lower the detection limit to siglow * cosmics = dilate3(cosmics) # <<<<<<<<<<<<<< * cosmics = np.logical_and(cosmics, goodpix) * */ __Pyx_GetModuleGlobalName(__pyx_t_1, __pyx_n_s_dilate3); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 381, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_t_9 = NULL; __pyx_t_13 = 0; #if CYTHON_UNPACK_METHODS if (unlikely(PyMethod_Check(__pyx_t_1))) { __pyx_t_9 = PyMethod_GET_SELF(__pyx_t_1); if (likely(__pyx_t_9)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_1); __Pyx_INCREF(__pyx_t_9); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_1, function); __pyx_t_13 = 1; } } #endif { PyObject *__pyx_callargs[2] = {__pyx_t_9, __pyx_v_cosmics}; __pyx_t_4 = __Pyx_PyObject_FastCall(__pyx_t_1, __pyx_callargs+1-__pyx_t_13, 1+__pyx_t_13); __Pyx_XDECREF(__pyx_t_9); __pyx_t_9 = 0; if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 381, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; } __Pyx_DECREF_SET(__pyx_v_cosmics, __pyx_t_4); __pyx_t_4 = 0; /* "astroscrappy/astroscrappy.pyx":382 * # Now we repeat this procedure, but lower the detection limit to siglow * cosmics = dilate3(cosmics) * cosmics = np.logical_and(cosmics, goodpix) # <<<<<<<<<<<<<< * * del goodpix */ __Pyx_GetModuleGlobalName(__pyx_t_1, __pyx_n_s_np); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 382, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_t_9 = __Pyx_PyObject_GetAttrStr(__pyx_t_1, __pyx_n_s_logical_and); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 382, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_9); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __pyx_t_1 = NULL; __pyx_t_13 = 0; #if CYTHON_UNPACK_METHODS if (unlikely(PyMethod_Check(__pyx_t_9))) { __pyx_t_1 = PyMethod_GET_SELF(__pyx_t_9); if (likely(__pyx_t_1)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_9); __Pyx_INCREF(__pyx_t_1); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_9, function); __pyx_t_13 = 1; } } #endif { PyObject *__pyx_callargs[3] = {__pyx_t_1, __pyx_v_cosmics, __pyx_v_goodpix}; __pyx_t_4 = __Pyx_PyObject_FastCall(__pyx_t_9, __pyx_callargs+1-__pyx_t_13, 2+__pyx_t_13); __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0; if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 382, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; } __Pyx_DECREF_SET(__pyx_v_cosmics, __pyx_t_4); __pyx_t_4 = 0; /* "astroscrappy/astroscrappy.pyx":384 * cosmics = np.logical_and(cosmics, goodpix) * * del goodpix # <<<<<<<<<<<<<< * cosmics = np.logical_and(sp > sigcliplow, cosmics) * del sp */ __Pyx_DECREF(__pyx_v_goodpix); __pyx_v_goodpix = 0; /* "astroscrappy/astroscrappy.pyx":385 * * del goodpix * cosmics = np.logical_and(sp > sigcliplow, cosmics) # <<<<<<<<<<<<<< * del sp * */ __Pyx_GetModuleGlobalName(__pyx_t_9, __pyx_n_s_np); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 385, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_9); __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_t_9, __pyx_n_s_logical_and); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 385, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; __pyx_t_9 = PyFloat_FromDouble(__pyx_v_sigcliplow); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 385, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_9); __pyx_t_5 = PyObject_RichCompare(__pyx_v_sp, __pyx_t_9, Py_GT); __Pyx_XGOTREF(__pyx_t_5); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 385, __pyx_L1_error) __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; __pyx_t_9 = NULL; __pyx_t_13 = 0; #if CYTHON_UNPACK_METHODS if (unlikely(PyMethod_Check(__pyx_t_1))) { __pyx_t_9 = PyMethod_GET_SELF(__pyx_t_1); if (likely(__pyx_t_9)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_1); __Pyx_INCREF(__pyx_t_9); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_1, function); __pyx_t_13 = 1; } } #endif { PyObject *__pyx_callargs[3] = {__pyx_t_9, __pyx_t_5, __pyx_v_cosmics}; __pyx_t_4 = __Pyx_PyObject_FastCall(__pyx_t_1, __pyx_callargs+1-__pyx_t_13, 2+__pyx_t_13); __Pyx_XDECREF(__pyx_t_9); __pyx_t_9 = 0; __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 385, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; } __Pyx_DECREF_SET(__pyx_v_cosmics, __pyx_t_4); __pyx_t_4 = 0; /* "astroscrappy/astroscrappy.pyx":386 * del goodpix * cosmics = np.logical_and(sp > sigcliplow, cosmics) * del sp # <<<<<<<<<<<<<< * * # Our CR counter */ __Pyx_DECREF(__pyx_v_sp); __pyx_v_sp = 0; /* "astroscrappy/astroscrappy.pyx":389 * * # Our CR counter * numcr = cosmics.sum() # <<<<<<<<<<<<<< * * # Update the crmask with the cosmics we have found */ __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_cosmics, __pyx_n_s_sum); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 389, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_t_5 = NULL; __pyx_t_13 = 0; #if CYTHON_UNPACK_METHODS if (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_13 = 1; } } #endif { PyObject *__pyx_callargs[2] = {__pyx_t_5, NULL}; __pyx_t_4 = __Pyx_PyObject_FastCall(__pyx_t_1, __pyx_callargs+1-__pyx_t_13, 0+__pyx_t_13); __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0; if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 389, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; } __Pyx_XDECREF_SET(__pyx_v_numcr, __pyx_t_4); __pyx_t_4 = 0; /* "astroscrappy/astroscrappy.pyx":392 * * # Update the crmask with the cosmics we have found * crmask[:, :] = np.logical_or(crmask, cosmics)[:, :] # <<<<<<<<<<<<<< * del cosmics * if verbose: */ __Pyx_GetModuleGlobalName(__pyx_t_1, __pyx_n_s_np); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 392, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_t_1, __pyx_n_s_logical_or); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 392, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_5); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __pyx_t_1 = NULL; __pyx_t_13 = 0; #if CYTHON_UNPACK_METHODS if (unlikely(PyMethod_Check(__pyx_t_5))) { __pyx_t_1 = PyMethod_GET_SELF(__pyx_t_5); if (likely(__pyx_t_1)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_5); __Pyx_INCREF(__pyx_t_1); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_5, function); __pyx_t_13 = 1; } } #endif { PyObject *__pyx_callargs[3] = {__pyx_t_1, __pyx_v_crmask, __pyx_v_cosmics}; __pyx_t_4 = __Pyx_PyObject_FastCall(__pyx_t_5, __pyx_callargs+1-__pyx_t_13, 2+__pyx_t_13); __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0; if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 392, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; } __pyx_t_5 = __Pyx_PyObject_GetItem(__pyx_t_4, __pyx_tuple__11); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 392, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_5); __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; if (unlikely((PyObject_SetItem(__pyx_v_crmask, __pyx_tuple__11, __pyx_t_5) < 0))) __PYX_ERR(0, 392, __pyx_L1_error) __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; /* "astroscrappy/astroscrappy.pyx":393 * # Update the crmask with the cosmics we have found * crmask[:, :] = np.logical_or(crmask, cosmics)[:, :] * del cosmics # <<<<<<<<<<<<<< * if verbose: * print("{} cosmic pixels this iteration".format(numcr)) */ __Pyx_DECREF(__pyx_v_cosmics); __pyx_v_cosmics = 0; /* "astroscrappy/astroscrappy.pyx":394 * crmask[:, :] = np.logical_or(crmask, cosmics)[:, :] * del cosmics * if verbose: # <<<<<<<<<<<<<< * print("{} cosmic pixels this iteration".format(numcr)) * */ __pyx_t_7 = __Pyx_PyObject_IsTrue(__pyx_v_verbose); if (unlikely((__pyx_t_7 < 0))) __PYX_ERR(0, 394, __pyx_L1_error) if (__pyx_t_7) { /* "astroscrappy/astroscrappy.pyx":395 * del cosmics * if verbose: * print("{} cosmic pixels this iteration".format(numcr)) # <<<<<<<<<<<<<< * * # If we didn't find anything, we're done. */ __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_kp_u_cosmic_pixels_this_iteration, __pyx_n_s_format); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 395, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __pyx_t_1 = NULL; __pyx_t_13 = 0; #if CYTHON_UNPACK_METHODS if (likely(PyMethod_Check(__pyx_t_4))) { __pyx_t_1 = PyMethod_GET_SELF(__pyx_t_4); if (likely(__pyx_t_1)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_4); __Pyx_INCREF(__pyx_t_1); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_4, function); __pyx_t_13 = 1; } } #endif { PyObject *__pyx_callargs[2] = {__pyx_t_1, __pyx_v_numcr}; __pyx_t_5 = __Pyx_PyObject_FastCall(__pyx_t_4, __pyx_callargs+1-__pyx_t_13, 1+__pyx_t_13); __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0; if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 395, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_5); __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; } __pyx_t_4 = __Pyx_PyObject_CallOneArg(__pyx_builtin_print, __pyx_t_5); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 395, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; /* "astroscrappy/astroscrappy.pyx":394 * crmask[:, :] = np.logical_or(crmask, cosmics)[:, :] * del cosmics * if verbose: # <<<<<<<<<<<<<< * print("{} cosmic pixels this iteration".format(numcr)) * */ } /* "astroscrappy/astroscrappy.pyx":398 * * # If we didn't find anything, we're done. * if numcr == 0: # <<<<<<<<<<<<<< * break * */ __pyx_t_7 = (__Pyx_PyInt_BoolEqObjC(__pyx_v_numcr, __pyx_int_0, 0, 0)); if (unlikely((__pyx_t_7 < 0))) __PYX_ERR(0, 398, __pyx_L1_error) if (__pyx_t_7) { /* "astroscrappy/astroscrappy.pyx":399 * # If we didn't find anything, we're done. * if numcr == 0: * break # <<<<<<<<<<<<<< * * # otherwise clean the image and iterate */ goto __pyx_L19_break; /* "astroscrappy/astroscrappy.pyx":398 * * # If we didn't find anything, we're done. * if numcr == 0: # <<<<<<<<<<<<<< * break * */ } /* "astroscrappy/astroscrappy.pyx":402 * * # otherwise clean the image and iterate * if cleantype == 'median': # <<<<<<<<<<<<<< * # Unmasked median filter * clean_median(cleanarr, crmask, nx, ny) */ __pyx_t_7 = (__Pyx_PyUnicode_Equals(__pyx_v_cleantype, __pyx_n_u_median, Py_EQ)); if (unlikely((__pyx_t_7 < 0))) __PYX_ERR(0, 402, __pyx_L1_error) if (__pyx_t_7) { /* "astroscrappy/astroscrappy.pyx":404 * if cleantype == 'median': * # Unmasked median filter * clean_median(cleanarr, crmask, nx, ny) # <<<<<<<<<<<<<< * clean_median(clean_var, crmask, nx, ny) * # Masked mean filter */ __pyx_t_14 = __Pyx_PyObject_to_MemoryviewSlice_d_dc_float(__pyx_v_cleanarr, PyBUF_WRITABLE); if (unlikely(!__pyx_t_14.memview)) __PYX_ERR(0, 404, __pyx_L1_error) __pyx_t_15 = __Pyx_PyObject_to_MemoryviewSlice_d_dc_nn___pyx_t_12astroscrappy_12astroscrappy_bool(__pyx_v_crmask, PyBUF_WRITABLE); if (unlikely(!__pyx_t_15.memview)) __PYX_ERR(0, 404, __pyx_L1_error) __pyx_f_12astroscrappy_12astroscrappy_clean_median(__pyx_t_14, __pyx_t_15, __pyx_v_nx, __pyx_v_ny); if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 404, __pyx_L1_error) __PYX_XCLEAR_MEMVIEW(&__pyx_t_14, 1); __pyx_t_14.memview = NULL; __pyx_t_14.data = NULL; __PYX_XCLEAR_MEMVIEW(&__pyx_t_15, 1); __pyx_t_15.memview = NULL; __pyx_t_15.data = NULL; /* "astroscrappy/astroscrappy.pyx":405 * # Unmasked median filter * clean_median(cleanarr, crmask, nx, ny) * clean_median(clean_var, crmask, nx, ny) # <<<<<<<<<<<<<< * # Masked mean filter * elif cleantype == 'meanmask': */ __pyx_t_14 = __Pyx_PyObject_to_MemoryviewSlice_d_dc_float(__pyx_v_clean_var, PyBUF_WRITABLE); if (unlikely(!__pyx_t_14.memview)) __PYX_ERR(0, 405, __pyx_L1_error) __pyx_t_15 = __Pyx_PyObject_to_MemoryviewSlice_d_dc_nn___pyx_t_12astroscrappy_12astroscrappy_bool(__pyx_v_crmask, PyBUF_WRITABLE); if (unlikely(!__pyx_t_15.memview)) __PYX_ERR(0, 405, __pyx_L1_error) __pyx_f_12astroscrappy_12astroscrappy_clean_median(__pyx_t_14, __pyx_t_15, __pyx_v_nx, __pyx_v_ny); if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 405, __pyx_L1_error) __PYX_XCLEAR_MEMVIEW(&__pyx_t_14, 1); __pyx_t_14.memview = NULL; __pyx_t_14.data = NULL; __PYX_XCLEAR_MEMVIEW(&__pyx_t_15, 1); __pyx_t_15.memview = NULL; __pyx_t_15.data = NULL; /* "astroscrappy/astroscrappy.pyx":402 * * # otherwise clean the image and iterate * if cleantype == 'median': # <<<<<<<<<<<<<< * # Unmasked median filter * clean_median(cleanarr, crmask, nx, ny) */ goto __pyx_L29; } /* "astroscrappy/astroscrappy.pyx":407 * clean_median(clean_var, crmask, nx, ny) * # Masked mean filter * elif cleantype == 'meanmask': # <<<<<<<<<<<<<< * clean_meanmask(cleanarr, crmask, mask, nx, ny, background_level) * clean_meanmask(clean_var, crmask, mask, nx, ny, background_var_level) */ __pyx_t_7 = (__Pyx_PyUnicode_Equals(__pyx_v_cleantype, __pyx_n_u_meanmask, Py_EQ)); if (unlikely((__pyx_t_7 < 0))) __PYX_ERR(0, 407, __pyx_L1_error) if (__pyx_t_7) { /* "astroscrappy/astroscrappy.pyx":408 * # Masked mean filter * elif cleantype == 'meanmask': * clean_meanmask(cleanarr, crmask, mask, nx, ny, background_level) # <<<<<<<<<<<<<< * clean_meanmask(clean_var, crmask, mask, nx, ny, background_var_level) * # Masked median filter */ __pyx_t_14 = __Pyx_PyObject_to_MemoryviewSlice_d_dc_float(__pyx_v_cleanarr, PyBUF_WRITABLE); if (unlikely(!__pyx_t_14.memview)) __PYX_ERR(0, 408, __pyx_L1_error) __pyx_t_15 = __Pyx_PyObject_to_MemoryviewSlice_d_dc_nn___pyx_t_12astroscrappy_12astroscrappy_bool(__pyx_v_crmask, PyBUF_WRITABLE); if (unlikely(!__pyx_t_15.memview)) __PYX_ERR(0, 408, __pyx_L1_error) __pyx_t_16 = __Pyx_PyObject_to_MemoryviewSlice_d_dc_nn___pyx_t_12astroscrappy_12astroscrappy_bool(__pyx_v_mask, PyBUF_WRITABLE); if (unlikely(!__pyx_t_16.memview)) __PYX_ERR(0, 408, __pyx_L1_error) __pyx_t_17 = __pyx_PyFloat_AsFloat(__pyx_v_background_level); if (unlikely((__pyx_t_17 == (float)-1) && PyErr_Occurred())) __PYX_ERR(0, 408, __pyx_L1_error) __pyx_f_12astroscrappy_12astroscrappy_clean_meanmask(__pyx_t_14, __pyx_t_15, __pyx_t_16, __pyx_v_nx, __pyx_v_ny, __pyx_t_17); if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 408, __pyx_L1_error) __PYX_XCLEAR_MEMVIEW(&__pyx_t_14, 1); __pyx_t_14.memview = NULL; __pyx_t_14.data = NULL; __PYX_XCLEAR_MEMVIEW(&__pyx_t_15, 1); __pyx_t_15.memview = NULL; __pyx_t_15.data = NULL; __PYX_XCLEAR_MEMVIEW(&__pyx_t_16, 1); __pyx_t_16.memview = NULL; __pyx_t_16.data = NULL; /* "astroscrappy/astroscrappy.pyx":409 * elif cleantype == 'meanmask': * clean_meanmask(cleanarr, crmask, mask, nx, ny, background_level) * clean_meanmask(clean_var, crmask, mask, nx, ny, background_var_level) # <<<<<<<<<<<<<< * # Masked median filter * elif cleantype == 'medmask': */ __pyx_t_14 = __Pyx_PyObject_to_MemoryviewSlice_d_dc_float(__pyx_v_clean_var, PyBUF_WRITABLE); if (unlikely(!__pyx_t_14.memview)) __PYX_ERR(0, 409, __pyx_L1_error) __pyx_t_16 = __Pyx_PyObject_to_MemoryviewSlice_d_dc_nn___pyx_t_12astroscrappy_12astroscrappy_bool(__pyx_v_crmask, PyBUF_WRITABLE); if (unlikely(!__pyx_t_16.memview)) __PYX_ERR(0, 409, __pyx_L1_error) __pyx_t_15 = __Pyx_PyObject_to_MemoryviewSlice_d_dc_nn___pyx_t_12astroscrappy_12astroscrappy_bool(__pyx_v_mask, PyBUF_WRITABLE); if (unlikely(!__pyx_t_15.memview)) __PYX_ERR(0, 409, __pyx_L1_error) __pyx_t_17 = __pyx_PyFloat_AsFloat(__pyx_v_background_var_level); if (unlikely((__pyx_t_17 == (float)-1) && PyErr_Occurred())) __PYX_ERR(0, 409, __pyx_L1_error) __pyx_f_12astroscrappy_12astroscrappy_clean_meanmask(__pyx_t_14, __pyx_t_16, __pyx_t_15, __pyx_v_nx, __pyx_v_ny, __pyx_t_17); if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 409, __pyx_L1_error) __PYX_XCLEAR_MEMVIEW(&__pyx_t_14, 1); __pyx_t_14.memview = NULL; __pyx_t_14.data = NULL; __PYX_XCLEAR_MEMVIEW(&__pyx_t_16, 1); __pyx_t_16.memview = NULL; __pyx_t_16.data = NULL; __PYX_XCLEAR_MEMVIEW(&__pyx_t_15, 1); __pyx_t_15.memview = NULL; __pyx_t_15.data = NULL; /* "astroscrappy/astroscrappy.pyx":407 * clean_median(clean_var, crmask, nx, ny) * # Masked mean filter * elif cleantype == 'meanmask': # <<<<<<<<<<<<<< * clean_meanmask(cleanarr, crmask, mask, nx, ny, background_level) * clean_meanmask(clean_var, crmask, mask, nx, ny, background_var_level) */ goto __pyx_L29; } /* "astroscrappy/astroscrappy.pyx":411 * clean_meanmask(clean_var, crmask, mask, nx, ny, background_var_level) * # Masked median filter * elif cleantype == 'medmask': # <<<<<<<<<<<<<< * clean_medmask(cleanarr, crmask, mask, nx, ny, background_level) * clean_medmask(clean_var, crmask, mask, nx, ny, background_var_level) */ __pyx_t_7 = (__Pyx_PyUnicode_Equals(__pyx_v_cleantype, __pyx_n_u_medmask, Py_EQ)); if (unlikely((__pyx_t_7 < 0))) __PYX_ERR(0, 411, __pyx_L1_error) if (__pyx_t_7) { /* "astroscrappy/astroscrappy.pyx":412 * # Masked median filter * elif cleantype == 'medmask': * clean_medmask(cleanarr, crmask, mask, nx, ny, background_level) # <<<<<<<<<<<<<< * clean_medmask(clean_var, crmask, mask, nx, ny, background_var_level) * # Inverse distance weighted interpolation */ __pyx_t_14 = __Pyx_PyObject_to_MemoryviewSlice_d_dc_float(__pyx_v_cleanarr, PyBUF_WRITABLE); if (unlikely(!__pyx_t_14.memview)) __PYX_ERR(0, 412, __pyx_L1_error) __pyx_t_15 = __Pyx_PyObject_to_MemoryviewSlice_d_dc_nn___pyx_t_12astroscrappy_12astroscrappy_bool(__pyx_v_crmask, PyBUF_WRITABLE); if (unlikely(!__pyx_t_15.memview)) __PYX_ERR(0, 412, __pyx_L1_error) __pyx_t_16 = __Pyx_PyObject_to_MemoryviewSlice_d_dc_nn___pyx_t_12astroscrappy_12astroscrappy_bool(__pyx_v_mask, PyBUF_WRITABLE); if (unlikely(!__pyx_t_16.memview)) __PYX_ERR(0, 412, __pyx_L1_error) __pyx_t_17 = __pyx_PyFloat_AsFloat(__pyx_v_background_level); if (unlikely((__pyx_t_17 == (float)-1) && PyErr_Occurred())) __PYX_ERR(0, 412, __pyx_L1_error) __pyx_f_12astroscrappy_12astroscrappy_clean_medmask(__pyx_t_14, __pyx_t_15, __pyx_t_16, __pyx_v_nx, __pyx_v_ny, __pyx_t_17); if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 412, __pyx_L1_error) __PYX_XCLEAR_MEMVIEW(&__pyx_t_14, 1); __pyx_t_14.memview = NULL; __pyx_t_14.data = NULL; __PYX_XCLEAR_MEMVIEW(&__pyx_t_15, 1); __pyx_t_15.memview = NULL; __pyx_t_15.data = NULL; __PYX_XCLEAR_MEMVIEW(&__pyx_t_16, 1); __pyx_t_16.memview = NULL; __pyx_t_16.data = NULL; /* "astroscrappy/astroscrappy.pyx":413 * elif cleantype == 'medmask': * clean_medmask(cleanarr, crmask, mask, nx, ny, background_level) * clean_medmask(clean_var, crmask, mask, nx, ny, background_var_level) # <<<<<<<<<<<<<< * # Inverse distance weighted interpolation * elif cleantype == 'idw': */ __pyx_t_14 = __Pyx_PyObject_to_MemoryviewSlice_d_dc_float(__pyx_v_clean_var, PyBUF_WRITABLE); if (unlikely(!__pyx_t_14.memview)) __PYX_ERR(0, 413, __pyx_L1_error) __pyx_t_16 = __Pyx_PyObject_to_MemoryviewSlice_d_dc_nn___pyx_t_12astroscrappy_12astroscrappy_bool(__pyx_v_crmask, PyBUF_WRITABLE); if (unlikely(!__pyx_t_16.memview)) __PYX_ERR(0, 413, __pyx_L1_error) __pyx_t_15 = __Pyx_PyObject_to_MemoryviewSlice_d_dc_nn___pyx_t_12astroscrappy_12astroscrappy_bool(__pyx_v_mask, PyBUF_WRITABLE); if (unlikely(!__pyx_t_15.memview)) __PYX_ERR(0, 413, __pyx_L1_error) __pyx_t_17 = __pyx_PyFloat_AsFloat(__pyx_v_background_var_level); if (unlikely((__pyx_t_17 == (float)-1) && PyErr_Occurred())) __PYX_ERR(0, 413, __pyx_L1_error) __pyx_f_12astroscrappy_12astroscrappy_clean_medmask(__pyx_t_14, __pyx_t_16, __pyx_t_15, __pyx_v_nx, __pyx_v_ny, __pyx_t_17); if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 413, __pyx_L1_error) __PYX_XCLEAR_MEMVIEW(&__pyx_t_14, 1); __pyx_t_14.memview = NULL; __pyx_t_14.data = NULL; __PYX_XCLEAR_MEMVIEW(&__pyx_t_16, 1); __pyx_t_16.memview = NULL; __pyx_t_16.data = NULL; __PYX_XCLEAR_MEMVIEW(&__pyx_t_15, 1); __pyx_t_15.memview = NULL; __pyx_t_15.data = NULL; /* "astroscrappy/astroscrappy.pyx":411 * clean_meanmask(clean_var, crmask, mask, nx, ny, background_var_level) * # Masked median filter * elif cleantype == 'medmask': # <<<<<<<<<<<<<< * clean_medmask(cleanarr, crmask, mask, nx, ny, background_level) * clean_medmask(clean_var, crmask, mask, nx, ny, background_var_level) */ goto __pyx_L29; } /* "astroscrappy/astroscrappy.pyx":415 * clean_medmask(clean_var, crmask, mask, nx, ny, background_var_level) * # Inverse distance weighted interpolation * elif cleantype == 'idw': # <<<<<<<<<<<<<< * clean_idwinterp(cleanarr, crmask, mask, nx, ny, background_level) * clean_idwinterp(clean_var, crmask, mask, nx, ny, background_var_level) */ __pyx_t_7 = (__Pyx_PyUnicode_Equals(__pyx_v_cleantype, __pyx_n_u_idw, Py_EQ)); if (unlikely((__pyx_t_7 < 0))) __PYX_ERR(0, 415, __pyx_L1_error) if (likely(__pyx_t_7)) { /* "astroscrappy/astroscrappy.pyx":416 * # Inverse distance weighted interpolation * elif cleantype == 'idw': * clean_idwinterp(cleanarr, crmask, mask, nx, ny, background_level) # <<<<<<<<<<<<<< * clean_idwinterp(clean_var, crmask, mask, nx, ny, background_var_level) * else: */ __pyx_t_14 = __Pyx_PyObject_to_MemoryviewSlice_d_dc_float(__pyx_v_cleanarr, PyBUF_WRITABLE); if (unlikely(!__pyx_t_14.memview)) __PYX_ERR(0, 416, __pyx_L1_error) __pyx_t_15 = __Pyx_PyObject_to_MemoryviewSlice_d_dc_nn___pyx_t_12astroscrappy_12astroscrappy_bool(__pyx_v_crmask, PyBUF_WRITABLE); if (unlikely(!__pyx_t_15.memview)) __PYX_ERR(0, 416, __pyx_L1_error) __pyx_t_16 = __Pyx_PyObject_to_MemoryviewSlice_d_dc_nn___pyx_t_12astroscrappy_12astroscrappy_bool(__pyx_v_mask, PyBUF_WRITABLE); if (unlikely(!__pyx_t_16.memview)) __PYX_ERR(0, 416, __pyx_L1_error) __pyx_t_17 = __pyx_PyFloat_AsFloat(__pyx_v_background_level); if (unlikely((__pyx_t_17 == (float)-1) && PyErr_Occurred())) __PYX_ERR(0, 416, __pyx_L1_error) __pyx_f_12astroscrappy_12astroscrappy_clean_idwinterp(__pyx_t_14, __pyx_t_15, __pyx_t_16, __pyx_v_nx, __pyx_v_ny, __pyx_t_17); if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 416, __pyx_L1_error) __PYX_XCLEAR_MEMVIEW(&__pyx_t_14, 1); __pyx_t_14.memview = NULL; __pyx_t_14.data = NULL; __PYX_XCLEAR_MEMVIEW(&__pyx_t_15, 1); __pyx_t_15.memview = NULL; __pyx_t_15.data = NULL; __PYX_XCLEAR_MEMVIEW(&__pyx_t_16, 1); __pyx_t_16.memview = NULL; __pyx_t_16.data = NULL; /* "astroscrappy/astroscrappy.pyx":417 * elif cleantype == 'idw': * clean_idwinterp(cleanarr, crmask, mask, nx, ny, background_level) * clean_idwinterp(clean_var, crmask, mask, nx, ny, background_var_level) # <<<<<<<<<<<<<< * else: * raise ValueError("""cleantype must be one of the following values: */ __pyx_t_14 = __Pyx_PyObject_to_MemoryviewSlice_d_dc_float(__pyx_v_clean_var, PyBUF_WRITABLE); if (unlikely(!__pyx_t_14.memview)) __PYX_ERR(0, 417, __pyx_L1_error) __pyx_t_16 = __Pyx_PyObject_to_MemoryviewSlice_d_dc_nn___pyx_t_12astroscrappy_12astroscrappy_bool(__pyx_v_crmask, PyBUF_WRITABLE); if (unlikely(!__pyx_t_16.memview)) __PYX_ERR(0, 417, __pyx_L1_error) __pyx_t_15 = __Pyx_PyObject_to_MemoryviewSlice_d_dc_nn___pyx_t_12astroscrappy_12astroscrappy_bool(__pyx_v_mask, PyBUF_WRITABLE); if (unlikely(!__pyx_t_15.memview)) __PYX_ERR(0, 417, __pyx_L1_error) __pyx_t_17 = __pyx_PyFloat_AsFloat(__pyx_v_background_var_level); if (unlikely((__pyx_t_17 == (float)-1) && PyErr_Occurred())) __PYX_ERR(0, 417, __pyx_L1_error) __pyx_f_12astroscrappy_12astroscrappy_clean_idwinterp(__pyx_t_14, __pyx_t_16, __pyx_t_15, __pyx_v_nx, __pyx_v_ny, __pyx_t_17); if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 417, __pyx_L1_error) __PYX_XCLEAR_MEMVIEW(&__pyx_t_14, 1); __pyx_t_14.memview = NULL; __pyx_t_14.data = NULL; __PYX_XCLEAR_MEMVIEW(&__pyx_t_16, 1); __pyx_t_16.memview = NULL; __pyx_t_16.data = NULL; __PYX_XCLEAR_MEMVIEW(&__pyx_t_15, 1); __pyx_t_15.memview = NULL; __pyx_t_15.data = NULL; /* "astroscrappy/astroscrappy.pyx":415 * clean_medmask(clean_var, crmask, mask, nx, ny, background_var_level) * # Inverse distance weighted interpolation * elif cleantype == 'idw': # <<<<<<<<<<<<<< * clean_idwinterp(cleanarr, crmask, mask, nx, ny, background_level) * clean_idwinterp(clean_var, crmask, mask, nx, ny, background_var_level) */ goto __pyx_L29; } /* "astroscrappy/astroscrappy.pyx":419 * clean_idwinterp(clean_var, crmask, mask, nx, ny, background_var_level) * else: * raise ValueError("""cleantype must be one of the following values: # <<<<<<<<<<<<<< * [median, meanmask, medmask, idw]""") * */ /*else*/ { __pyx_t_4 = __Pyx_PyObject_Call(__pyx_builtin_ValueError, __pyx_tuple__16, NULL); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 419, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __Pyx_Raise(__pyx_t_4, 0, 0, 0); __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __PYX_ERR(0, 419, __pyx_L1_error) } __pyx_L29:; } __pyx_L19_break:; /* "astroscrappy/astroscrappy.pyx":423 * * # Restore the sky background if needed. * if inbkg is not None: # <<<<<<<<<<<<<< * cleanarr += bkg * */ __pyx_t_7 = (__pyx_v_inbkg != Py_None); if (__pyx_t_7) { /* "astroscrappy/astroscrappy.pyx":424 * # Restore the sky background if needed. * if inbkg is not None: * cleanarr += bkg # <<<<<<<<<<<<<< * * cleanarr /= gain */ if (unlikely(!__pyx_v_bkg)) { __Pyx_RaiseUnboundLocalError("bkg"); __PYX_ERR(0, 424, __pyx_L1_error) } __pyx_t_4 = PyNumber_InPlaceAdd(__pyx_v_cleanarr, __pyx_v_bkg); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 424, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __Pyx_DECREF_SET(__pyx_v_cleanarr, __pyx_t_4); __pyx_t_4 = 0; /* "astroscrappy/astroscrappy.pyx":423 * * # Restore the sky background if needed. * if inbkg is not None: # <<<<<<<<<<<<<< * cleanarr += bkg * */ } /* "astroscrappy/astroscrappy.pyx":426 * cleanarr += bkg * * cleanarr /= gain # <<<<<<<<<<<<<< * * return crmask.astype(np.bool_), cleanarr */ __pyx_t_4 = PyFloat_FromDouble(__pyx_v_gain); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 426, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __pyx_t_5 = __Pyx_PyNumber_InPlaceDivide(__pyx_v_cleanarr, __pyx_t_4); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 426, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_5); __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __Pyx_DECREF_SET(__pyx_v_cleanarr, __pyx_t_5); __pyx_t_5 = 0; /* "astroscrappy/astroscrappy.pyx":428 * cleanarr /= gain * * return crmask.astype(np.bool_), cleanarr # <<<<<<<<<<<<<< * * */ __Pyx_XDECREF(__pyx_r); __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_v_crmask, __pyx_n_s_astype); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 428, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __Pyx_GetModuleGlobalName(__pyx_t_1, __pyx_n_s_np); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 428, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_t_9 = __Pyx_PyObject_GetAttrStr(__pyx_t_1, __pyx_n_s_bool); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 428, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_9); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __pyx_t_1 = NULL; __pyx_t_3 = 0; #if CYTHON_UNPACK_METHODS if (likely(PyMethod_Check(__pyx_t_4))) { __pyx_t_1 = PyMethod_GET_SELF(__pyx_t_4); if (likely(__pyx_t_1)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_4); __Pyx_INCREF(__pyx_t_1); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_4, function); __pyx_t_3 = 1; } } #endif { PyObject *__pyx_callargs[2] = {__pyx_t_1, __pyx_t_9}; __pyx_t_5 = __Pyx_PyObject_FastCall(__pyx_t_4, __pyx_callargs+1-__pyx_t_3, 1+__pyx_t_3); __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0; __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 428, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_5); __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; } __pyx_t_4 = PyTuple_New(2); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 428, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __Pyx_GIVEREF(__pyx_t_5); if (__Pyx_PyTuple_SET_ITEM(__pyx_t_4, 0, __pyx_t_5)) __PYX_ERR(0, 428, __pyx_L1_error); __Pyx_INCREF(__pyx_v_cleanarr); __Pyx_GIVEREF(__pyx_v_cleanarr); if (__Pyx_PyTuple_SET_ITEM(__pyx_t_4, 1, __pyx_v_cleanarr)) __PYX_ERR(0, 428, __pyx_L1_error); __pyx_t_5 = 0; __pyx_r = __pyx_t_4; __pyx_t_4 = 0; goto __pyx_L0; /* "astroscrappy/astroscrappy.pyx":26 * from libc.stdlib cimport malloc, free * * def detect_cosmics(indat, inmask=None, inbkg=None, invar=None, float sigclip=4.5, # <<<<<<<<<<<<<< * float sigfrac=0.3, float objlim=5.0, float gain=1.0, * float readnoise=6.5, float satlevel=65536.0, */ /* 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_9); __PYX_XCLEAR_MEMVIEW(&__pyx_t_14, 1); __PYX_XCLEAR_MEMVIEW(&__pyx_t_15, 1); __PYX_XCLEAR_MEMVIEW(&__pyx_t_16, 1); __Pyx_AddTraceback("astroscrappy.astroscrappy.detect_cosmics", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __pyx_L0:; __Pyx_XDECREF(__pyx_v_cleanarr); __Pyx_XDECREF(__pyx_v_bkg); __Pyx_XDECREF(__pyx_v_mask); __Pyx_XDECREF(__pyx_v_clean_var); __Pyx_XDECREF(__pyx_v_gooddata); __Pyx_XDECREF(__pyx_v_background_level); __Pyx_XDECREF(__pyx_v_goodvar); __Pyx_XDECREF(__pyx_v_background_var_level); __Pyx_XDECREF(__pyx_v_crmask); __Pyx_XDECREF(__pyx_v_subsam); __Pyx_XDECREF(__pyx_v_conved); __Pyx_XDECREF(__pyx_v_s); __Pyx_XDECREF(__pyx_v_m5); __Pyx_XDECREF(__pyx_v_noise); __Pyx_XDECREF(__pyx_v_sp); __Pyx_XDECREF(__pyx_v_goodpix); __Pyx_XDECREF(__pyx_v_cosmics); __Pyx_XDECREF(__pyx_v_f); __Pyx_XDECREF(__pyx_v_m7); __Pyx_XDECREF(__pyx_v_numcr); __Pyx_XDECREF(__pyx_v_psfk); __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "astroscrappy/astroscrappy.pyx":431 * * * def update_mask(np.ndarray[np.float32_t, ndim=2, mode='c', cast=True] data, # <<<<<<<<<<<<<< * np.ndarray[np.uint8_t, ndim=2, mode='c', cast=True] mask, * float satlevel, bool sepmed): */ /* Python wrapper */ static PyObject *__pyx_pw_12astroscrappy_12astroscrappy_3update_mask(PyObject *__pyx_self, #if CYTHON_METH_FASTCALL PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds #else PyObject *__pyx_args, PyObject *__pyx_kwds #endif ); /*proto*/ PyDoc_STRVAR(__pyx_doc_12astroscrappy_12astroscrappy_2update_mask, "update_mask(data, mask, satlevel, sepmed)\n\n Find staturated stars and puts them in the mask.\n\n This can then be used to avoid these regions in cosmic detection and\n cleaning procedures. The median filter is used to find large symmetric\n regions of saturated pixels (i.e. saturated stars).\n\n Parameters\n ----------\n data : float numpy array\n The data array in which we look for saturated stars.\n\n mask : boolean numpy array\n Bad pixel mask. This mask will be dilated using dilate3 and then\n combined with the saturated star mask.\n\n satlevel : float\n Saturation level of the image. This value can be lowered if the cores\n of bright (saturated) stars are not being masked.\n\n sepmed : boolean\n Use the separable median or not. The separable median is not identical\n to the full median filter, but they are approximately the same and the\n separable median filter is significantly faster.\n "); static PyMethodDef __pyx_mdef_12astroscrappy_12astroscrappy_3update_mask = {"update_mask", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_12astroscrappy_12astroscrappy_3update_mask, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_12astroscrappy_12astroscrappy_2update_mask}; static PyObject *__pyx_pw_12astroscrappy_12astroscrappy_3update_mask(PyObject *__pyx_self, #if CYTHON_METH_FASTCALL PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds #else PyObject *__pyx_args, PyObject *__pyx_kwds #endif ) { PyArrayObject *__pyx_v_data = 0; PyArrayObject *__pyx_v_mask = 0; float __pyx_v_satlevel; __pyx_t_12astroscrappy_12astroscrappy_bool __pyx_v_sepmed; #if !CYTHON_METH_FASTCALL CYTHON_UNUSED Py_ssize_t __pyx_nargs; #endif CYTHON_UNUSED PyObject *const *__pyx_kwvalues; PyObject* values[4] = {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("update_mask (wrapper)", 0); #if !CYTHON_METH_FASTCALL #if CYTHON_ASSUME_SAFE_MACROS __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); #else __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; #endif #endif __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); { PyObject **__pyx_pyargnames[] = {&__pyx_n_s_data,&__pyx_n_s_mask,&__pyx_n_s_satlevel,&__pyx_n_s_sepmed,0}; if (__pyx_kwds) { Py_ssize_t kw_args; switch (__pyx_nargs) { case 4: values[3] = __Pyx_Arg_FASTCALL(__pyx_args, 3); CYTHON_FALLTHROUGH; case 3: values[2] = __Pyx_Arg_FASTCALL(__pyx_args, 2); CYTHON_FALLTHROUGH; case 2: values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); CYTHON_FALLTHROUGH; case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); CYTHON_FALLTHROUGH; case 0: break; default: goto __pyx_L5_argtuple_error; } kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); switch (__pyx_nargs) { case 0: if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_data)) != 0)) { (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); kw_args--; } else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 431, __pyx_L3_error) else goto __pyx_L5_argtuple_error; CYTHON_FALLTHROUGH; case 1: if (likely((values[1] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_mask)) != 0)) { (void)__Pyx_Arg_NewRef_FASTCALL(values[1]); kw_args--; } else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 431, __pyx_L3_error) else { __Pyx_RaiseArgtupleInvalid("update_mask", 1, 4, 4, 1); __PYX_ERR(0, 431, __pyx_L3_error) } CYTHON_FALLTHROUGH; case 2: if (likely((values[2] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_satlevel)) != 0)) { (void)__Pyx_Arg_NewRef_FASTCALL(values[2]); kw_args--; } else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 431, __pyx_L3_error) else { __Pyx_RaiseArgtupleInvalid("update_mask", 1, 4, 4, 2); __PYX_ERR(0, 431, __pyx_L3_error) } CYTHON_FALLTHROUGH; case 3: if (likely((values[3] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_sepmed)) != 0)) { (void)__Pyx_Arg_NewRef_FASTCALL(values[3]); kw_args--; } else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 431, __pyx_L3_error) else { __Pyx_RaiseArgtupleInvalid("update_mask", 1, 4, 4, 3); __PYX_ERR(0, 431, __pyx_L3_error) } } if (unlikely(kw_args > 0)) { const Py_ssize_t kwd_pos_args = __pyx_nargs; if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "update_mask") < 0)) __PYX_ERR(0, 431, __pyx_L3_error) } } else if (unlikely(__pyx_nargs != 4)) { goto __pyx_L5_argtuple_error; } else { values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); values[2] = __Pyx_Arg_FASTCALL(__pyx_args, 2); values[3] = __Pyx_Arg_FASTCALL(__pyx_args, 3); } __pyx_v_data = ((PyArrayObject *)values[0]); __pyx_v_mask = ((PyArrayObject *)values[1]); __pyx_v_satlevel = __pyx_PyFloat_AsFloat(values[2]); if (unlikely((__pyx_v_satlevel == (float)-1) && PyErr_Occurred())) __PYX_ERR(0, 433, __pyx_L3_error) __pyx_v_sepmed = __Pyx_PyInt_As_uint8_t(values[3]); if (unlikely((__pyx_v_sepmed == ((uint8_t)-1)) && PyErr_Occurred())) __PYX_ERR(0, 433, __pyx_L3_error) } goto __pyx_L6_skip; __pyx_L5_argtuple_error:; __Pyx_RaiseArgtupleInvalid("update_mask", 1, 4, 4, __pyx_nargs); __PYX_ERR(0, 431, __pyx_L3_error) __pyx_L6_skip:; goto __pyx_L4_argument_unpacking_done; __pyx_L3_error:; { Py_ssize_t __pyx_temp; for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); } } __Pyx_AddTraceback("astroscrappy.astroscrappy.update_mask", __pyx_clineno, __pyx_lineno, __pyx_filename); __Pyx_RefNannyFinishContext(); return NULL; __pyx_L4_argument_unpacking_done:; if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_data), __pyx_ptype_5numpy_ndarray, 1, "data", 0))) __PYX_ERR(0, 431, __pyx_L1_error) if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_mask), __pyx_ptype_5numpy_ndarray, 1, "mask", 0))) __PYX_ERR(0, 432, __pyx_L1_error) __pyx_r = __pyx_pf_12astroscrappy_12astroscrappy_2update_mask(__pyx_self, __pyx_v_data, __pyx_v_mask, __pyx_v_satlevel, __pyx_v_sepmed); /* function exit code */ goto __pyx_L0; __pyx_L1_error:; __pyx_r = NULL; __pyx_L0:; { Py_ssize_t __pyx_temp; for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); } } __Pyx_RefNannyFinishContext(); return __pyx_r; } static PyObject *__pyx_pf_12astroscrappy_12astroscrappy_2update_mask(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_data, PyArrayObject *__pyx_v_mask, float __pyx_v_satlevel, __pyx_t_12astroscrappy_12astroscrappy_bool __pyx_v_sepmed) { PyObject *__pyx_v_satpixels = NULL; PyObject *__pyx_v_m5 = NULL; PyObject *__pyx_v_grow_mask = NULL; PyObject *__pyx_v_dilsatpixels = NULL; __Pyx_LocalBuf_ND __pyx_pybuffernd_data; __Pyx_Buffer __pyx_pybuffer_data; __Pyx_LocalBuf_ND __pyx_pybuffernd_mask; __Pyx_Buffer __pyx_pybuffer_mask; PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; PyObject *__pyx_t_2 = NULL; int __pyx_t_3; PyObject *__pyx_t_4 = NULL; int __pyx_t_5; PyObject *__pyx_t_6 = NULL; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("update_mask", 1); __pyx_pybuffer_data.pybuffer.buf = NULL; __pyx_pybuffer_data.refcount = 0; __pyx_pybuffernd_data.data = NULL; __pyx_pybuffernd_data.rcbuffer = &__pyx_pybuffer_data; __pyx_pybuffer_mask.pybuffer.buf = NULL; __pyx_pybuffer_mask.refcount = 0; __pyx_pybuffernd_mask.data = NULL; __pyx_pybuffernd_mask.rcbuffer = &__pyx_pybuffer_mask; { __Pyx_BufFmt_StackElem __pyx_stack[1]; if (unlikely(__Pyx_GetBufferAndValidate(&__pyx_pybuffernd_data.rcbuffer->pybuffer, (PyObject*)__pyx_v_data, &__Pyx_TypeInfo_nn___pyx_t_5numpy_float32_t, PyBUF_FORMAT| PyBUF_C_CONTIGUOUS, 2, 1, __pyx_stack) == -1)) __PYX_ERR(0, 431, __pyx_L1_error) } __pyx_pybuffernd_data.diminfo[0].strides = __pyx_pybuffernd_data.rcbuffer->pybuffer.strides[0]; __pyx_pybuffernd_data.diminfo[0].shape = __pyx_pybuffernd_data.rcbuffer->pybuffer.shape[0]; __pyx_pybuffernd_data.diminfo[1].strides = __pyx_pybuffernd_data.rcbuffer->pybuffer.strides[1]; __pyx_pybuffernd_data.diminfo[1].shape = __pyx_pybuffernd_data.rcbuffer->pybuffer.shape[1]; { __Pyx_BufFmt_StackElem __pyx_stack[1]; if (unlikely(__Pyx_GetBufferAndValidate(&__pyx_pybuffernd_mask.rcbuffer->pybuffer, (PyObject*)__pyx_v_mask, &__Pyx_TypeInfo_nn___pyx_t_5numpy_uint8_t, PyBUF_FORMAT| PyBUF_C_CONTIGUOUS, 2, 1, __pyx_stack) == -1)) __PYX_ERR(0, 431, __pyx_L1_error) } __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]; __pyx_pybuffernd_mask.diminfo[1].strides = __pyx_pybuffernd_mask.rcbuffer->pybuffer.strides[1]; __pyx_pybuffernd_mask.diminfo[1].shape = __pyx_pybuffernd_mask.rcbuffer->pybuffer.shape[1]; /* "astroscrappy/astroscrappy.pyx":461 * * # Find all of the saturated pixels * satpixels = data >= satlevel # <<<<<<<<<<<<<< * * # Use the median filter to estimate the large scale structure */ __pyx_t_1 = PyFloat_FromDouble(__pyx_v_satlevel); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 461, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_t_2 = PyObject_RichCompare(((PyObject *)__pyx_v_data), __pyx_t_1, Py_GE); __Pyx_XGOTREF(__pyx_t_2); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 461, __pyx_L1_error) __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __pyx_v_satpixels = __pyx_t_2; __pyx_t_2 = 0; /* "astroscrappy/astroscrappy.pyx":464 * * # Use the median filter to estimate the large scale structure * if sepmed: # <<<<<<<<<<<<<< * m5 = sepmedfilt7(data) * else: */ __pyx_t_3 = (__pyx_v_sepmed != 0); if (__pyx_t_3) { /* "astroscrappy/astroscrappy.pyx":465 * # Use the median filter to estimate the large scale structure * if sepmed: * m5 = sepmedfilt7(data) # <<<<<<<<<<<<<< * else: * m5 = medfilt5(data) */ __Pyx_GetModuleGlobalName(__pyx_t_1, __pyx_n_s_sepmedfilt7); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 465, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_t_4 = NULL; __pyx_t_5 = 0; #if CYTHON_UNPACK_METHODS if (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_5 = 1; } } #endif { PyObject *__pyx_callargs[2] = {__pyx_t_4, ((PyObject *)__pyx_v_data)}; __pyx_t_2 = __Pyx_PyObject_FastCall(__pyx_t_1, __pyx_callargs+1-__pyx_t_5, 1+__pyx_t_5); __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 465, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; } __pyx_v_m5 = __pyx_t_2; __pyx_t_2 = 0; /* "astroscrappy/astroscrappy.pyx":464 * * # Use the median filter to estimate the large scale structure * if sepmed: # <<<<<<<<<<<<<< * m5 = sepmedfilt7(data) * else: */ goto __pyx_L3; } /* "astroscrappy/astroscrappy.pyx":467 * m5 = sepmedfilt7(data) * else: * m5 = medfilt5(data) # <<<<<<<<<<<<<< * * # Use the median filtered image to find the cores of saturated stars */ /*else*/ { __Pyx_GetModuleGlobalName(__pyx_t_1, __pyx_n_s_medfilt5); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 467, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_t_4 = NULL; __pyx_t_5 = 0; #if CYTHON_UNPACK_METHODS if (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_5 = 1; } } #endif { PyObject *__pyx_callargs[2] = {__pyx_t_4, ((PyObject *)__pyx_v_data)}; __pyx_t_2 = __Pyx_PyObject_FastCall(__pyx_t_1, __pyx_callargs+1-__pyx_t_5, 1+__pyx_t_5); __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 467, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; } __pyx_v_m5 = __pyx_t_2; __pyx_t_2 = 0; } __pyx_L3:; /* "astroscrappy/astroscrappy.pyx":472 * # The 10 here is arbitray. Malte Tewes uses 2.0 in cosmics.py, but I * # wanted to get more of the cores of saturated stars. * satpixels = np.logical_and(satpixels, m5 > (satlevel / 10.0)) # <<<<<<<<<<<<<< * * # Grow the input mask by one pixel to make sure we cover bad pixels */ __Pyx_GetModuleGlobalName(__pyx_t_1, __pyx_n_s_np); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 472, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_t_1, __pyx_n_s_logical_and); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 472, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __pyx_t_1 = PyFloat_FromDouble((((double)__pyx_v_satlevel) / 10.0)); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 472, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_t_6 = PyObject_RichCompare(__pyx_v_m5, __pyx_t_1, Py_GT); __Pyx_XGOTREF(__pyx_t_6); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 472, __pyx_L1_error) __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __pyx_t_1 = NULL; __pyx_t_5 = 0; #if CYTHON_UNPACK_METHODS if (unlikely(PyMethod_Check(__pyx_t_4))) { __pyx_t_1 = PyMethod_GET_SELF(__pyx_t_4); if (likely(__pyx_t_1)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_4); __Pyx_INCREF(__pyx_t_1); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_4, function); __pyx_t_5 = 1; } } #endif { PyObject *__pyx_callargs[3] = {__pyx_t_1, __pyx_v_satpixels, __pyx_t_6}; __pyx_t_2 = __Pyx_PyObject_FastCall(__pyx_t_4, __pyx_callargs+1-__pyx_t_5, 2+__pyx_t_5); __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0; __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 472, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; } __Pyx_DECREF_SET(__pyx_v_satpixels, __pyx_t_2); __pyx_t_2 = 0; /* "astroscrappy/astroscrappy.pyx":475 * * # Grow the input mask by one pixel to make sure we cover bad pixels * grow_mask = dilate3(mask) # <<<<<<<<<<<<<< * * # Dilate the saturated star mask to remove edge effects in the mask */ __Pyx_GetModuleGlobalName(__pyx_t_4, __pyx_n_s_dilate3); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 475, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __pyx_t_6 = NULL; __pyx_t_5 = 0; #if CYTHON_UNPACK_METHODS if (unlikely(PyMethod_Check(__pyx_t_4))) { __pyx_t_6 = PyMethod_GET_SELF(__pyx_t_4); if (likely(__pyx_t_6)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_4); __Pyx_INCREF(__pyx_t_6); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_4, function); __pyx_t_5 = 1; } } #endif { PyObject *__pyx_callargs[2] = {__pyx_t_6, ((PyObject *)__pyx_v_mask)}; __pyx_t_2 = __Pyx_PyObject_FastCall(__pyx_t_4, __pyx_callargs+1-__pyx_t_5, 1+__pyx_t_5); __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0; if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 475, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; } __pyx_v_grow_mask = __pyx_t_2; __pyx_t_2 = 0; /* "astroscrappy/astroscrappy.pyx":478 * * # Dilate the saturated star mask to remove edge effects in the mask * dilsatpixels = dilate5(satpixels, 2) # <<<<<<<<<<<<<< * del satpixels * # Combine the saturated pixels with the given input mask */ __Pyx_GetModuleGlobalName(__pyx_t_4, __pyx_n_s_dilate5); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 478, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __pyx_t_6 = NULL; __pyx_t_5 = 0; #if CYTHON_UNPACK_METHODS if (unlikely(PyMethod_Check(__pyx_t_4))) { __pyx_t_6 = PyMethod_GET_SELF(__pyx_t_4); if (likely(__pyx_t_6)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_4); __Pyx_INCREF(__pyx_t_6); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_4, function); __pyx_t_5 = 1; } } #endif { PyObject *__pyx_callargs[3] = {__pyx_t_6, __pyx_v_satpixels, __pyx_int_2}; __pyx_t_2 = __Pyx_PyObject_FastCall(__pyx_t_4, __pyx_callargs+1-__pyx_t_5, 2+__pyx_t_5); __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0; if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 478, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; } __pyx_v_dilsatpixels = __pyx_t_2; __pyx_t_2 = 0; /* "astroscrappy/astroscrappy.pyx":479 * # Dilate the saturated star mask to remove edge effects in the mask * dilsatpixels = dilate5(satpixels, 2) * del satpixels # <<<<<<<<<<<<<< * # Combine the saturated pixels with the given input mask * # Note, we work on the mask pixels in place */ __Pyx_DECREF(__pyx_v_satpixels); __pyx_v_satpixels = 0; /* "astroscrappy/astroscrappy.pyx":482 * # Combine the saturated pixels with the given input mask * # Note, we work on the mask pixels in place * mask[:, :] = np.logical_or(dilsatpixels, grow_mask)[:, :] # <<<<<<<<<<<<<< * del grow_mask * */ __Pyx_GetModuleGlobalName(__pyx_t_4, __pyx_n_s_np); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 482, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_t_4, __pyx_n_s_logical_or); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 482, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __pyx_t_4 = NULL; __pyx_t_5 = 0; #if CYTHON_UNPACK_METHODS if (unlikely(PyMethod_Check(__pyx_t_6))) { __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_6); if (likely(__pyx_t_4)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_6); __Pyx_INCREF(__pyx_t_4); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_6, function); __pyx_t_5 = 1; } } #endif { PyObject *__pyx_callargs[3] = {__pyx_t_4, __pyx_v_dilsatpixels, __pyx_v_grow_mask}; __pyx_t_2 = __Pyx_PyObject_FastCall(__pyx_t_6, __pyx_callargs+1-__pyx_t_5, 2+__pyx_t_5); __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 482, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; } __pyx_t_6 = __Pyx_PyObject_GetItem(__pyx_t_2, __pyx_tuple__11); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 482, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; if (unlikely((PyObject_SetItem(((PyObject *)__pyx_v_mask), __pyx_tuple__11, __pyx_t_6) < 0))) __PYX_ERR(0, 482, __pyx_L1_error) __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; /* "astroscrappy/astroscrappy.pyx":483 * # Note, we work on the mask pixels in place * mask[:, :] = np.logical_or(dilsatpixels, grow_mask)[:, :] * del grow_mask # <<<<<<<<<<<<<< * * */ __Pyx_DECREF(__pyx_v_grow_mask); __pyx_v_grow_mask = 0; /* "astroscrappy/astroscrappy.pyx":431 * * * def update_mask(np.ndarray[np.float32_t, ndim=2, mode='c', cast=True] data, # <<<<<<<<<<<<<< * np.ndarray[np.uint8_t, ndim=2, mode='c', cast=True] mask, * float satlevel, bool sepmed): */ /* 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_4); __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_data.rcbuffer->pybuffer); __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_mask.rcbuffer->pybuffer); __Pyx_ErrRestore(__pyx_type, __pyx_value, __pyx_tb);} __Pyx_AddTraceback("astroscrappy.astroscrappy.update_mask", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; goto __pyx_L2; __pyx_L0:; __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_data.rcbuffer->pybuffer); __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_mask.rcbuffer->pybuffer); __pyx_L2:; __Pyx_XDECREF(__pyx_v_satpixels); __Pyx_XDECREF(__pyx_v_m5); __Pyx_XDECREF(__pyx_v_grow_mask); __Pyx_XDECREF(__pyx_v_dilsatpixels); __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "astroscrappy/astroscrappy.pyx":486 * * * cdef void clean_meanmask(float[:, ::1] cleanarr, bool[:, ::1] crmask, # <<<<<<<<<<<<<< * bool[:, ::1] mask, int nx, int ny, * float background_level): */ static void __pyx_f_12astroscrappy_12astroscrappy_clean_meanmask(__Pyx_memviewslice __pyx_v_cleanarr, __Pyx_memviewslice __pyx_v_crmask, __Pyx_memviewslice __pyx_v_mask, int __pyx_v_nx, CYTHON_UNUSED int __pyx_v_ny, float __pyx_v_background_level) { int __pyx_v_i; int __pyx_v_j; int __pyx_v_k; int __pyx_v_l; int __pyx_v_numpix; float __pyx_v_s; __pyx_t_12astroscrappy_12astroscrappy_bool __pyx_v_badpix; long __pyx_t_1; long __pyx_t_2; long __pyx_t_3; long __pyx_t_4; long __pyx_t_5; int __pyx_t_6; Py_ssize_t __pyx_t_7; Py_ssize_t __pyx_t_8; int __pyx_t_9; int __pyx_t_10; int __pyx_t_11; __pyx_t_12astroscrappy_12astroscrappy_bool __pyx_t_12; __pyx_t_12astroscrappy_12astroscrappy_bool __pyx_t_13; /* "astroscrappy/astroscrappy.pyx":522 * cdef bool badpix * * with nogil, parallel(): # <<<<<<<<<<<<<< * # For each pixel * for j in prange(2, ny - 2): */ { #ifdef WITH_THREAD PyThreadState *_save; _save = NULL; Py_UNBLOCK_THREADS __Pyx_FastGIL_Remember(); #endif /*try:*/ { { #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 #ifdef _OPENMP #pragma omp parallel private(__pyx_t_1, __pyx_t_10, __pyx_t_11, __pyx_t_12, __pyx_t_13, __pyx_t_2, __pyx_t_3, __pyx_t_4, __pyx_t_5, __pyx_t_6, __pyx_t_7, __pyx_t_8, __pyx_t_9) #endif /* _OPENMP */ { /* "astroscrappy/astroscrappy.pyx":524 * with nogil, parallel(): * # For each pixel * for j in prange(2, ny - 2): # <<<<<<<<<<<<<< * for i in range(2, nx - 2): * # if the pixel is in the crmask */ __pyx_t_1 = (__pyx_v_ny - 2); { __pyx_t_3 = (__pyx_t_1 - 2 + 1 - 1/abs(1)) / 1; if (__pyx_t_3 > 0) { #ifdef _OPENMP #pragma omp for lastprivate(__pyx_v_badpix) lastprivate(__pyx_v_i) firstprivate(__pyx_v_j) lastprivate(__pyx_v_j) lastprivate(__pyx_v_k) lastprivate(__pyx_v_l) lastprivate(__pyx_v_numpix) lastprivate(__pyx_v_s) #endif /* _OPENMP */ for (__pyx_t_2 = 0; __pyx_t_2 < __pyx_t_3; __pyx_t_2++){ { __pyx_v_j = (int)(2 + 1 * __pyx_t_2); /* Initialize private variables to invalid values */ __pyx_v_badpix = ((__pyx_t_12astroscrappy_12astroscrappy_bool)'?'); __pyx_v_i = ((int)0xbad0bad0); __pyx_v_k = ((int)0xbad0bad0); __pyx_v_l = ((int)0xbad0bad0); __pyx_v_numpix = ((int)0xbad0bad0); __pyx_v_s = ((float)__PYX_NAN()); /* "astroscrappy/astroscrappy.pyx":525 * # For each pixel * for j in prange(2, ny - 2): * for i in range(2, nx - 2): # <<<<<<<<<<<<<< * # if the pixel is in the crmask * if crmask[j, i]: */ __pyx_t_4 = (__pyx_v_nx - 2); __pyx_t_5 = __pyx_t_4; for (__pyx_t_6 = 2; __pyx_t_6 < __pyx_t_5; __pyx_t_6+=1) { __pyx_v_i = __pyx_t_6; /* "astroscrappy/astroscrappy.pyx":527 * for i in range(2, nx - 2): * # if the pixel is in the crmask * if crmask[j, i]: # <<<<<<<<<<<<<< * numpix = 0 * s = 0.0 */ __pyx_t_7 = __pyx_v_j; __pyx_t_8 = __pyx_v_i; __pyx_t_9 = ((*((__pyx_t_12astroscrappy_12astroscrappy_bool *) ( /* dim=1 */ ((char *) (((__pyx_t_12astroscrappy_12astroscrappy_bool *) ( /* dim=0 */ (__pyx_v_crmask.data + __pyx_t_7 * __pyx_v_crmask.strides[0]) )) + __pyx_t_8)) ))) != 0); if (__pyx_t_9) { /* "astroscrappy/astroscrappy.pyx":528 * # if the pixel is in the crmask * if crmask[j, i]: * numpix = 0 # <<<<<<<<<<<<<< * s = 0.0 * */ __pyx_v_numpix = 0; /* "astroscrappy/astroscrappy.pyx":529 * if crmask[j, i]: * numpix = 0 * s = 0.0 # <<<<<<<<<<<<<< * * # sum the 25 pixels around the pixel */ __pyx_v_s = 0.0; /* "astroscrappy/astroscrappy.pyx":533 * # sum the 25 pixels around the pixel * # ignoring any pixels that are masked * for l in range(-2, 3): # <<<<<<<<<<<<<< * for k in range(-2, 3): * badpix = crmask[j + l, i + k] */ for (__pyx_t_10 = -2; __pyx_t_10 < 3; __pyx_t_10+=1) { __pyx_v_l = __pyx_t_10; /* "astroscrappy/astroscrappy.pyx":534 * # ignoring any pixels that are masked * for l in range(-2, 3): * for k in range(-2, 3): # <<<<<<<<<<<<<< * badpix = crmask[j + l, i + k] * badpix = badpix or mask[j + l, i + k] */ for (__pyx_t_11 = -2; __pyx_t_11 < 3; __pyx_t_11+=1) { __pyx_v_k = __pyx_t_11; /* "astroscrappy/astroscrappy.pyx":535 * for l in range(-2, 3): * for k in range(-2, 3): * badpix = crmask[j + l, i + k] # <<<<<<<<<<<<<< * badpix = badpix or mask[j + l, i + k] * if not badpix: */ __pyx_t_8 = (__pyx_v_j + __pyx_v_l); __pyx_t_7 = (__pyx_v_i + __pyx_v_k); __pyx_v_badpix = (*((__pyx_t_12astroscrappy_12astroscrappy_bool *) ( /* dim=1 */ ((char *) (((__pyx_t_12astroscrappy_12astroscrappy_bool *) ( /* dim=0 */ (__pyx_v_crmask.data + __pyx_t_8 * __pyx_v_crmask.strides[0]) )) + __pyx_t_7)) ))); /* "astroscrappy/astroscrappy.pyx":536 * for k in range(-2, 3): * badpix = crmask[j + l, i + k] * badpix = badpix or mask[j + l, i + k] # <<<<<<<<<<<<<< * if not badpix: * s = s + cleanarr[j + l, i + k] */ if (!__pyx_v_badpix) { } else { __pyx_t_12 = __pyx_v_badpix; goto __pyx_L21_bool_binop_done; } __pyx_t_7 = (__pyx_v_j + __pyx_v_l); __pyx_t_8 = (__pyx_v_i + __pyx_v_k); __pyx_t_13 = (*((__pyx_t_12astroscrappy_12astroscrappy_bool *) ( /* dim=1 */ ((char *) (((__pyx_t_12astroscrappy_12astroscrappy_bool *) ( /* dim=0 */ (__pyx_v_mask.data + __pyx_t_7 * __pyx_v_mask.strides[0]) )) + __pyx_t_8)) ))); __pyx_t_12 = __pyx_t_13; __pyx_L21_bool_binop_done:; __pyx_v_badpix = __pyx_t_12; /* "astroscrappy/astroscrappy.pyx":537 * badpix = crmask[j + l, i + k] * badpix = badpix or mask[j + l, i + k] * if not badpix: # <<<<<<<<<<<<<< * s = s + cleanarr[j + l, i + k] * numpix = numpix + 1 */ __pyx_t_9 = (!(__pyx_v_badpix != 0)); if (__pyx_t_9) { /* "astroscrappy/astroscrappy.pyx":538 * badpix = badpix or mask[j + l, i + k] * if not badpix: * s = s + cleanarr[j + l, i + k] # <<<<<<<<<<<<<< * numpix = numpix + 1 * */ __pyx_t_8 = (__pyx_v_j + __pyx_v_l); __pyx_t_7 = (__pyx_v_i + __pyx_v_k); __pyx_v_s = (__pyx_v_s + (*((float *) ( /* dim=1 */ ((char *) (((float *) ( /* dim=0 */ (__pyx_v_cleanarr.data + __pyx_t_8 * __pyx_v_cleanarr.strides[0]) )) + __pyx_t_7)) )))); /* "astroscrappy/astroscrappy.pyx":539 * if not badpix: * s = s + cleanarr[j + l, i + k] * numpix = numpix + 1 # <<<<<<<<<<<<<< * * # if the pixels count is 0 */ __pyx_v_numpix = (__pyx_v_numpix + 1); /* "astroscrappy/astroscrappy.pyx":537 * badpix = crmask[j + l, i + k] * badpix = badpix or mask[j + l, i + k] * if not badpix: # <<<<<<<<<<<<<< * s = s + cleanarr[j + l, i + k] * numpix = numpix + 1 */ } } } /* "astroscrappy/astroscrappy.pyx":543 * # if the pixels count is 0 * # then put in the background of the image * if numpix == 0: # <<<<<<<<<<<<<< * s = background_level * else: */ __pyx_t_9 = (__pyx_v_numpix == 0); if (__pyx_t_9) { /* "astroscrappy/astroscrappy.pyx":544 * # then put in the background of the image * if numpix == 0: * s = background_level # <<<<<<<<<<<<<< * else: * # else take the mean */ __pyx_v_s = __pyx_v_background_level; /* "astroscrappy/astroscrappy.pyx":543 * # if the pixels count is 0 * # then put in the background of the image * if numpix == 0: # <<<<<<<<<<<<<< * s = background_level * else: */ goto __pyx_L24; } /* "astroscrappy/astroscrappy.pyx":547 * else: * # else take the mean * s = s / float(numpix) # <<<<<<<<<<<<<< * * cleanarr[j, i] = s */ /*else*/ { __pyx_v_s = (((double)__pyx_v_s) / ((double)__pyx_v_numpix)); } __pyx_L24:; /* "astroscrappy/astroscrappy.pyx":549 * s = s / float(numpix) * * cleanarr[j, i] = s # <<<<<<<<<<<<<< * * */ __pyx_t_7 = __pyx_v_j; __pyx_t_8 = __pyx_v_i; *((float *) ( /* dim=1 */ ((char *) (((float *) ( /* dim=0 */ (__pyx_v_cleanarr.data + __pyx_t_7 * __pyx_v_cleanarr.strides[0]) )) + __pyx_t_8)) )) = __pyx_v_s; /* "astroscrappy/astroscrappy.pyx":527 * for i in range(2, nx - 2): * # if the pixel is in the crmask * if crmask[j, i]: # <<<<<<<<<<<<<< * numpix = 0 * s = 0.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 } /* "astroscrappy/astroscrappy.pyx":522 * cdef bool badpix * * with nogil, parallel(): # <<<<<<<<<<<<<< * # For each pixel * for j in prange(2, ny - 2): */ /*finally:*/ { /*normal exit:*/{ #ifdef WITH_THREAD __Pyx_FastGIL_Forget(); Py_BLOCK_THREADS #endif goto __pyx_L5; } __pyx_L5:; } } /* "astroscrappy/astroscrappy.pyx":486 * * * cdef void clean_meanmask(float[:, ::1] cleanarr, bool[:, ::1] crmask, # <<<<<<<<<<<<<< * bool[:, ::1] mask, int nx, int ny, * float background_level): */ /* function exit code */ } /* "astroscrappy/astroscrappy.pyx":552 * * * cdef void clean_median(float[:, ::1] cleanarr, bool[:, ::1] crmask, int nx, int ny): # <<<<<<<<<<<<<< * """clean_medmask(cleanarr, crmask, mask, nx, ny, background_level)\n * Clean the bad pixels in cleanarr using a 5x5 masked median filter. */ static void __pyx_f_12astroscrappy_12astroscrappy_clean_median(__Pyx_memviewslice __pyx_v_cleanarr, __Pyx_memviewslice __pyx_v_crmask, int __pyx_v_nx, CYTHON_UNUSED int __pyx_v_ny) { int __pyx_v_k; int __pyx_v_l; int __pyx_v_i; int __pyx_v_j; int __pyx_v_counter; float *__pyx_v_medarr; long __pyx_t_1; long __pyx_t_2; long __pyx_t_3; long __pyx_t_4; long __pyx_t_5; int __pyx_t_6; Py_ssize_t __pyx_t_7; Py_ssize_t __pyx_t_8; int __pyx_t_9; int __pyx_t_10; int __pyx_t_11; /* "astroscrappy/astroscrappy.pyx":578 * * # For each pixel * with nogil, parallel(): # <<<<<<<<<<<<<< * medarr = < float * > malloc(25 * sizeof(float)) * for j in prange(2, ny - 2): */ { #ifdef WITH_THREAD PyThreadState *_save; _save = NULL; Py_UNBLOCK_THREADS __Pyx_FastGIL_Remember(); #endif /*try:*/ { { #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 #ifdef _OPENMP #pragma omp parallel private(__pyx_v_medarr) private(__pyx_t_1, __pyx_t_10, __pyx_t_11, __pyx_t_2, __pyx_t_3, __pyx_t_4, __pyx_t_5, __pyx_t_6, __pyx_t_7, __pyx_t_8, __pyx_t_9) #endif /* _OPENMP */ { /* Initialize private variables to invalid values */ __pyx_v_medarr = ((float *)1); /* "astroscrappy/astroscrappy.pyx":579 * # For each pixel * with nogil, parallel(): * medarr = < float * > malloc(25 * sizeof(float)) # <<<<<<<<<<<<<< * for j in prange(2, ny - 2): * for i in range(2, nx - 2): */ __pyx_v_medarr = ((float *)malloc((25 * (sizeof(float))))); /* "astroscrappy/astroscrappy.pyx":580 * with nogil, parallel(): * medarr = < float * > malloc(25 * sizeof(float)) * for j in prange(2, ny - 2): # <<<<<<<<<<<<<< * for i in range(2, nx - 2): * # if the pixel is in the crmask */ __pyx_t_1 = (__pyx_v_ny - 2); { __pyx_t_3 = (__pyx_t_1 - 2 + 1 - 1/abs(1)) / 1; if (__pyx_t_3 > 0) { #ifdef _OPENMP #pragma omp for lastprivate(__pyx_v_counter) lastprivate(__pyx_v_i) firstprivate(__pyx_v_j) lastprivate(__pyx_v_j) lastprivate(__pyx_v_k) lastprivate(__pyx_v_l) #endif /* _OPENMP */ for (__pyx_t_2 = 0; __pyx_t_2 < __pyx_t_3; __pyx_t_2++){ { __pyx_v_j = (int)(2 + 1 * __pyx_t_2); /* Initialize private variables to invalid values */ __pyx_v_counter = ((int)0xbad0bad0); __pyx_v_i = ((int)0xbad0bad0); __pyx_v_k = ((int)0xbad0bad0); __pyx_v_l = ((int)0xbad0bad0); /* "astroscrappy/astroscrappy.pyx":581 * medarr = < float * > malloc(25 * sizeof(float)) * for j in prange(2, ny - 2): * for i in range(2, nx - 2): # <<<<<<<<<<<<<< * # if the pixel is in the crmask * if crmask[j, i]: */ __pyx_t_4 = (__pyx_v_nx - 2); __pyx_t_5 = __pyx_t_4; for (__pyx_t_6 = 2; __pyx_t_6 < __pyx_t_5; __pyx_t_6+=1) { __pyx_v_i = __pyx_t_6; /* "astroscrappy/astroscrappy.pyx":583 * for i in range(2, nx - 2): * # if the pixel is in the crmask * if crmask[j, i]: # <<<<<<<<<<<<<< * # median the 25 pixels around the pixel * counter = 0 */ __pyx_t_7 = __pyx_v_j; __pyx_t_8 = __pyx_v_i; __pyx_t_9 = ((*((__pyx_t_12astroscrappy_12astroscrappy_bool *) ( /* dim=1 */ ((char *) (((__pyx_t_12astroscrappy_12astroscrappy_bool *) ( /* dim=0 */ (__pyx_v_crmask.data + __pyx_t_7 * __pyx_v_crmask.strides[0]) )) + __pyx_t_8)) ))) != 0); if (__pyx_t_9) { /* "astroscrappy/astroscrappy.pyx":585 * if crmask[j, i]: * # median the 25 pixels around the pixel * counter = 0 # <<<<<<<<<<<<<< * for l in range(-2, 3): * for k in range(-2, 3): */ __pyx_v_counter = 0; /* "astroscrappy/astroscrappy.pyx":586 * # median the 25 pixels around the pixel * counter = 0 * for l in range(-2, 3): # <<<<<<<<<<<<<< * for k in range(-2, 3): * medarr[counter] = cleanarr[j + l, i + k] */ for (__pyx_t_10 = -2; __pyx_t_10 < 3; __pyx_t_10+=1) { __pyx_v_l = __pyx_t_10; /* "astroscrappy/astroscrappy.pyx":587 * counter = 0 * for l in range(-2, 3): * for k in range(-2, 3): # <<<<<<<<<<<<<< * medarr[counter] = cleanarr[j + l, i + k] * counter =+ 1 */ for (__pyx_t_11 = -2; __pyx_t_11 < 3; __pyx_t_11+=1) { __pyx_v_k = __pyx_t_11; /* "astroscrappy/astroscrappy.pyx":588 * for l in range(-2, 3): * for k in range(-2, 3): * medarr[counter] = cleanarr[j + l, i + k] # <<<<<<<<<<<<<< * counter =+ 1 * cleanarr[j, i] = cymedian(medarr, 25) */ __pyx_t_8 = (__pyx_v_j + __pyx_v_l); __pyx_t_7 = (__pyx_v_i + __pyx_v_k); (__pyx_v_medarr[__pyx_v_counter]) = (*((float *) ( /* dim=1 */ ((char *) (((float *) ( /* dim=0 */ (__pyx_v_cleanarr.data + __pyx_t_8 * __pyx_v_cleanarr.strides[0]) )) + __pyx_t_7)) ))); /* "astroscrappy/astroscrappy.pyx":589 * for k in range(-2, 3): * medarr[counter] = cleanarr[j + l, i + k] * counter =+ 1 # <<<<<<<<<<<<<< * cleanarr[j, i] = cymedian(medarr, 25) * */ __pyx_v_counter = 1; } } /* "astroscrappy/astroscrappy.pyx":590 * medarr[counter] = cleanarr[j + l, i + k] * counter =+ 1 * cleanarr[j, i] = cymedian(medarr, 25) # <<<<<<<<<<<<<< * * free(medarr) */ __pyx_t_7 = __pyx_v_j; __pyx_t_8 = __pyx_v_i; *((float *) ( /* dim=1 */ ((char *) (((float *) ( /* dim=0 */ (__pyx_v_cleanarr.data + __pyx_t_7 * __pyx_v_cleanarr.strides[0]) )) + __pyx_t_8)) )) = __pyx_f_12astroscrappy_5utils_12median_utils_cymedian(__pyx_v_medarr, 25); /* "astroscrappy/astroscrappy.pyx":583 * for i in range(2, nx - 2): * # if the pixel is in the crmask * if crmask[j, i]: # <<<<<<<<<<<<<< * # median the 25 pixels around the pixel * counter = 0 */ } } } } } } /* "astroscrappy/astroscrappy.pyx":592 * cleanarr[j, i] = cymedian(medarr, 25) * * free(medarr) # <<<<<<<<<<<<<< * * */ free(__pyx_v_medarr); } } #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 } /* "astroscrappy/astroscrappy.pyx":578 * * # For each pixel * with nogil, parallel(): # <<<<<<<<<<<<<< * medarr = < float * > malloc(25 * sizeof(float)) * for j in prange(2, ny - 2): */ /*finally:*/ { /*normal exit:*/{ #ifdef WITH_THREAD __Pyx_FastGIL_Forget(); Py_BLOCK_THREADS #endif goto __pyx_L5; } __pyx_L5:; } } /* "astroscrappy/astroscrappy.pyx":552 * * * cdef void clean_median(float[:, ::1] cleanarr, bool[:, ::1] crmask, int nx, int ny): # <<<<<<<<<<<<<< * """clean_medmask(cleanarr, crmask, mask, nx, ny, background_level)\n * Clean the bad pixels in cleanarr using a 5x5 masked median filter. */ /* function exit code */ } /* "astroscrappy/astroscrappy.pyx":595 * * * cdef void clean_medmask(float[:, ::1] cleanarr, bool[:, ::1] crmask, # <<<<<<<<<<<<<< * bool[:, ::1] mask, int nx, int ny, * float background_level): */ static void __pyx_f_12astroscrappy_12astroscrappy_clean_medmask(__Pyx_memviewslice __pyx_v_cleanarr, __Pyx_memviewslice __pyx_v_crmask, __Pyx_memviewslice __pyx_v_mask, int __pyx_v_nx, CYTHON_UNUSED int __pyx_v_ny, float __pyx_v_background_level) { int __pyx_v_k; int __pyx_v_l; int __pyx_v_i; int __pyx_v_j; int __pyx_v_numpix; float *__pyx_v_medarr; __pyx_t_12astroscrappy_12astroscrappy_bool __pyx_v_badpixel; long __pyx_t_1; long __pyx_t_2; long __pyx_t_3; long __pyx_t_4; long __pyx_t_5; int __pyx_t_6; Py_ssize_t __pyx_t_7; Py_ssize_t __pyx_t_8; int __pyx_t_9; int __pyx_t_10; int __pyx_t_11; __pyx_t_12astroscrappy_12astroscrappy_bool __pyx_t_12; __pyx_t_12astroscrappy_12astroscrappy_bool __pyx_t_13; /* "astroscrappy/astroscrappy.pyx":631 * * # For each pixel * with nogil, parallel(): # <<<<<<<<<<<<<< * medarr = < float * > malloc(25 * sizeof(float)) * for j in prange(2, ny - 2): */ { #ifdef WITH_THREAD PyThreadState *_save; _save = NULL; Py_UNBLOCK_THREADS __Pyx_FastGIL_Remember(); #endif /*try:*/ { { #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 #ifdef _OPENMP #pragma omp parallel private(__pyx_v_medarr) private(__pyx_t_1, __pyx_t_10, __pyx_t_11, __pyx_t_12, __pyx_t_13, __pyx_t_2, __pyx_t_3, __pyx_t_4, __pyx_t_5, __pyx_t_6, __pyx_t_7, __pyx_t_8, __pyx_t_9) #endif /* _OPENMP */ { /* Initialize private variables to invalid values */ __pyx_v_medarr = ((float *)1); /* "astroscrappy/astroscrappy.pyx":632 * # For each pixel * with nogil, parallel(): * medarr = < float * > malloc(25 * sizeof(float)) # <<<<<<<<<<<<<< * for j in prange(2, ny - 2): * for i in range(2, nx - 2): */ __pyx_v_medarr = ((float *)malloc((25 * (sizeof(float))))); /* "astroscrappy/astroscrappy.pyx":633 * with nogil, parallel(): * medarr = < float * > malloc(25 * sizeof(float)) * for j in prange(2, ny - 2): # <<<<<<<<<<<<<< * for i in range(2, nx - 2): * # if the pixel is in the crmask */ __pyx_t_1 = (__pyx_v_ny - 2); { __pyx_t_3 = (__pyx_t_1 - 2 + 1 - 1/abs(1)) / 1; if (__pyx_t_3 > 0) { #ifdef _OPENMP #pragma omp for lastprivate(__pyx_v_badpixel) lastprivate(__pyx_v_i) firstprivate(__pyx_v_j) lastprivate(__pyx_v_j) lastprivate(__pyx_v_k) lastprivate(__pyx_v_l) lastprivate(__pyx_v_numpix) #endif /* _OPENMP */ for (__pyx_t_2 = 0; __pyx_t_2 < __pyx_t_3; __pyx_t_2++){ { __pyx_v_j = (int)(2 + 1 * __pyx_t_2); /* Initialize private variables to invalid values */ __pyx_v_badpixel = ((__pyx_t_12astroscrappy_12astroscrappy_bool)'?'); __pyx_v_i = ((int)0xbad0bad0); __pyx_v_k = ((int)0xbad0bad0); __pyx_v_l = ((int)0xbad0bad0); __pyx_v_numpix = ((int)0xbad0bad0); /* "astroscrappy/astroscrappy.pyx":634 * medarr = < float * > malloc(25 * sizeof(float)) * for j in prange(2, ny - 2): * for i in range(2, nx - 2): # <<<<<<<<<<<<<< * # if the pixel is in the crmask * if crmask[j, i]: */ __pyx_t_4 = (__pyx_v_nx - 2); __pyx_t_5 = __pyx_t_4; for (__pyx_t_6 = 2; __pyx_t_6 < __pyx_t_5; __pyx_t_6+=1) { __pyx_v_i = __pyx_t_6; /* "astroscrappy/astroscrappy.pyx":636 * for i in range(2, nx - 2): * # if the pixel is in the crmask * if crmask[j, i]: # <<<<<<<<<<<<<< * numpix = 0 * # median the 25 pixels around the pixel ignoring */ __pyx_t_7 = __pyx_v_j; __pyx_t_8 = __pyx_v_i; __pyx_t_9 = ((*((__pyx_t_12astroscrappy_12astroscrappy_bool *) ( /* dim=1 */ ((char *) (((__pyx_t_12astroscrappy_12astroscrappy_bool *) ( /* dim=0 */ (__pyx_v_crmask.data + __pyx_t_7 * __pyx_v_crmask.strides[0]) )) + __pyx_t_8)) ))) != 0); if (__pyx_t_9) { /* "astroscrappy/astroscrappy.pyx":637 * # if the pixel is in the crmask * if crmask[j, i]: * numpix = 0 # <<<<<<<<<<<<<< * # median the 25 pixels around the pixel ignoring * # any pixels that are masked */ __pyx_v_numpix = 0; /* "astroscrappy/astroscrappy.pyx":640 * # median the 25 pixels around the pixel ignoring * # any pixels that are masked * for l in range(-2, 3): # <<<<<<<<<<<<<< * for k in range(-2, 3): * badpixel = crmask[j + l, i + k] */ for (__pyx_t_10 = -2; __pyx_t_10 < 3; __pyx_t_10+=1) { __pyx_v_l = __pyx_t_10; /* "astroscrappy/astroscrappy.pyx":641 * # any pixels that are masked * for l in range(-2, 3): * for k in range(-2, 3): # <<<<<<<<<<<<<< * badpixel = crmask[j + l, i + k] * badpixel = badpixel or mask[j + l, i + k] */ for (__pyx_t_11 = -2; __pyx_t_11 < 3; __pyx_t_11+=1) { __pyx_v_k = __pyx_t_11; /* "astroscrappy/astroscrappy.pyx":642 * for l in range(-2, 3): * for k in range(-2, 3): * badpixel = crmask[j + l, i + k] # <<<<<<<<<<<<<< * badpixel = badpixel or mask[j + l, i + k] * if not badpixel: */ __pyx_t_8 = (__pyx_v_j + __pyx_v_l); __pyx_t_7 = (__pyx_v_i + __pyx_v_k); __pyx_v_badpixel = (*((__pyx_t_12astroscrappy_12astroscrappy_bool *) ( /* dim=1 */ ((char *) (((__pyx_t_12astroscrappy_12astroscrappy_bool *) ( /* dim=0 */ (__pyx_v_crmask.data + __pyx_t_8 * __pyx_v_crmask.strides[0]) )) + __pyx_t_7)) ))); /* "astroscrappy/astroscrappy.pyx":643 * for k in range(-2, 3): * badpixel = crmask[j + l, i + k] * badpixel = badpixel or mask[j + l, i + k] # <<<<<<<<<<<<<< * if not badpixel: * medarr[numpix] = cleanarr[j + l, i + k] */ if (!__pyx_v_badpixel) { } else { __pyx_t_12 = __pyx_v_badpixel; goto __pyx_L21_bool_binop_done; } __pyx_t_7 = (__pyx_v_j + __pyx_v_l); __pyx_t_8 = (__pyx_v_i + __pyx_v_k); __pyx_t_13 = (*((__pyx_t_12astroscrappy_12astroscrappy_bool *) ( /* dim=1 */ ((char *) (((__pyx_t_12astroscrappy_12astroscrappy_bool *) ( /* dim=0 */ (__pyx_v_mask.data + __pyx_t_7 * __pyx_v_mask.strides[0]) )) + __pyx_t_8)) ))); __pyx_t_12 = __pyx_t_13; __pyx_L21_bool_binop_done:; __pyx_v_badpixel = __pyx_t_12; /* "astroscrappy/astroscrappy.pyx":644 * badpixel = crmask[j + l, i + k] * badpixel = badpixel or mask[j + l, i + k] * if not badpixel: # <<<<<<<<<<<<<< * medarr[numpix] = cleanarr[j + l, i + k] * numpix = numpix + 1 */ __pyx_t_9 = (!(__pyx_v_badpixel != 0)); if (__pyx_t_9) { /* "astroscrappy/astroscrappy.pyx":645 * badpixel = badpixel or mask[j + l, i + k] * if not badpixel: * medarr[numpix] = cleanarr[j + l, i + k] # <<<<<<<<<<<<<< * numpix = numpix + 1 * */ __pyx_t_8 = (__pyx_v_j + __pyx_v_l); __pyx_t_7 = (__pyx_v_i + __pyx_v_k); (__pyx_v_medarr[__pyx_v_numpix]) = (*((float *) ( /* dim=1 */ ((char *) (((float *) ( /* dim=0 */ (__pyx_v_cleanarr.data + __pyx_t_8 * __pyx_v_cleanarr.strides[0]) )) + __pyx_t_7)) ))); /* "astroscrappy/astroscrappy.pyx":646 * if not badpixel: * medarr[numpix] = cleanarr[j + l, i + k] * numpix = numpix + 1 # <<<<<<<<<<<<<< * * # if the pixels count is 0 then put in the background */ __pyx_v_numpix = (__pyx_v_numpix + 1); /* "astroscrappy/astroscrappy.pyx":644 * badpixel = crmask[j + l, i + k] * badpixel = badpixel or mask[j + l, i + k] * if not badpixel: # <<<<<<<<<<<<<< * medarr[numpix] = cleanarr[j + l, i + k] * numpix = numpix + 1 */ } } } /* "astroscrappy/astroscrappy.pyx":650 * # if the pixels count is 0 then put in the background * # of the image * if numpix == 0: # <<<<<<<<<<<<<< * cleanarr[j, i] = background_level * else: */ __pyx_t_9 = (__pyx_v_numpix == 0); if (__pyx_t_9) { /* "astroscrappy/astroscrappy.pyx":651 * # of the image * if numpix == 0: * cleanarr[j, i] = background_level # <<<<<<<<<<<<<< * else: * # else take the median */ __pyx_t_7 = __pyx_v_j; __pyx_t_8 = __pyx_v_i; *((float *) ( /* dim=1 */ ((char *) (((float *) ( /* dim=0 */ (__pyx_v_cleanarr.data + __pyx_t_7 * __pyx_v_cleanarr.strides[0]) )) + __pyx_t_8)) )) = __pyx_v_background_level; /* "astroscrappy/astroscrappy.pyx":650 * # if the pixels count is 0 then put in the background * # of the image * if numpix == 0: # <<<<<<<<<<<<<< * cleanarr[j, i] = background_level * else: */ goto __pyx_L24; } /* "astroscrappy/astroscrappy.pyx":654 * else: * # else take the median * cleanarr[j, i] = cymedian(medarr, numpix) # <<<<<<<<<<<<<< * * free(medarr) */ /*else*/ { __pyx_t_8 = __pyx_v_j; __pyx_t_7 = __pyx_v_i; *((float *) ( /* dim=1 */ ((char *) (((float *) ( /* dim=0 */ (__pyx_v_cleanarr.data + __pyx_t_8 * __pyx_v_cleanarr.strides[0]) )) + __pyx_t_7)) )) = __pyx_f_12astroscrappy_5utils_12median_utils_cymedian(__pyx_v_medarr, __pyx_v_numpix); } __pyx_L24:; /* "astroscrappy/astroscrappy.pyx":636 * for i in range(2, nx - 2): * # if the pixel is in the crmask * if crmask[j, i]: # <<<<<<<<<<<<<< * numpix = 0 * # median the 25 pixels around the pixel ignoring */ } } } } } } /* "astroscrappy/astroscrappy.pyx":656 * cleanarr[j, i] = cymedian(medarr, numpix) * * free(medarr) # <<<<<<<<<<<<<< * * */ free(__pyx_v_medarr); } } #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 } /* "astroscrappy/astroscrappy.pyx":631 * * # For each pixel * with nogil, parallel(): # <<<<<<<<<<<<<< * medarr = < float * > malloc(25 * sizeof(float)) * for j in prange(2, ny - 2): */ /*finally:*/ { /*normal exit:*/{ #ifdef WITH_THREAD __Pyx_FastGIL_Forget(); Py_BLOCK_THREADS #endif goto __pyx_L5; } __pyx_L5:; } } /* "astroscrappy/astroscrappy.pyx":595 * * * cdef void clean_medmask(float[:, ::1] cleanarr, bool[:, ::1] crmask, # <<<<<<<<<<<<<< * bool[:, ::1] mask, int nx, int ny, * float background_level): */ /* function exit code */ } /* "astroscrappy/astroscrappy.pyx":659 * * * cdef void clean_idwinterp(float[:, ::1] cleanarr, bool[:, ::1] crmask, # <<<<<<<<<<<<<< * bool[:, ::1] mask, int nx, int ny, * float background_level): */ static void __pyx_f_12astroscrappy_12astroscrappy_clean_idwinterp(__Pyx_memviewslice __pyx_v_cleanarr, __Pyx_memviewslice __pyx_v_crmask, __Pyx_memviewslice __pyx_v_mask, int __pyx_v_nx, CYTHON_UNUSED int __pyx_v_ny, float __pyx_v_background_level) { int __pyx_v_i; int __pyx_v_j; int __pyx_v_k; int __pyx_v_l; CYTHON_UNUSED float __pyx_v_f22; PyObject *__pyx_v_weightsarr = NULL; __Pyx_memviewslice __pyx_v_weights = { 0, 0, { 0 }, { 0 }, { 0 } }; float __pyx_v_wsum; float __pyx_v_val; int __pyx_v_x; int __pyx_v_y; __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; __Pyx_memviewslice __pyx_t_8 = { 0, 0, { 0 }, { 0 }, { 0 } }; long __pyx_t_9; long __pyx_t_10; long __pyx_t_11; long __pyx_t_12; long __pyx_t_13; int __pyx_t_14; Py_ssize_t __pyx_t_15; Py_ssize_t __pyx_t_16; int __pyx_t_17; int __pyx_t_18; int __pyx_t_19; int __pyx_t_20; Py_ssize_t __pyx_t_21; Py_ssize_t __pyx_t_22; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("clean_idwinterp", 1); /* "astroscrappy/astroscrappy.pyx":693 * # Go through all of the pixels, ignore the borders * cdef int i, j, k, l * cdef float f11, f12, f21, f22 = background_level # <<<<<<<<<<<<<< * cdef int x1, x2, y1, y2 * weightsarr = np.array([[0.35355339, 0.4472136, 0.5, 0.4472136, 0.35355339], */ __pyx_v_f22 = __pyx_v_background_level; /* "astroscrappy/astroscrappy.pyx":695 * cdef float f11, f12, f21, f22 = background_level * cdef int x1, x2, y1, y2 * weightsarr = np.array([[0.35355339, 0.4472136, 0.5, 0.4472136, 0.35355339], # <<<<<<<<<<<<<< * [0.4472136, 0.70710678, 1., 0.70710678, 0.4472136], * [0.5, 1., 0., 1., 0.5], */ __Pyx_GetModuleGlobalName(__pyx_t_1, __pyx_n_s_np); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 695, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_t_1, __pyx_n_s_array); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 695, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __pyx_t_1 = PyList_New(5); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 695, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_INCREF(__pyx_float_0_35355339); __Pyx_GIVEREF(__pyx_float_0_35355339); if (__Pyx_PyList_SET_ITEM(__pyx_t_1, 0, __pyx_float_0_35355339)) __PYX_ERR(0, 695, __pyx_L1_error); __Pyx_INCREF(__pyx_float_0_4472136); __Pyx_GIVEREF(__pyx_float_0_4472136); if (__Pyx_PyList_SET_ITEM(__pyx_t_1, 1, __pyx_float_0_4472136)) __PYX_ERR(0, 695, __pyx_L1_error); __Pyx_INCREF(__pyx_float_0_5); __Pyx_GIVEREF(__pyx_float_0_5); if (__Pyx_PyList_SET_ITEM(__pyx_t_1, 2, __pyx_float_0_5)) __PYX_ERR(0, 695, __pyx_L1_error); __Pyx_INCREF(__pyx_float_0_4472136); __Pyx_GIVEREF(__pyx_float_0_4472136); if (__Pyx_PyList_SET_ITEM(__pyx_t_1, 3, __pyx_float_0_4472136)) __PYX_ERR(0, 695, __pyx_L1_error); __Pyx_INCREF(__pyx_float_0_35355339); __Pyx_GIVEREF(__pyx_float_0_35355339); if (__Pyx_PyList_SET_ITEM(__pyx_t_1, 4, __pyx_float_0_35355339)) __PYX_ERR(0, 695, __pyx_L1_error); /* "astroscrappy/astroscrappy.pyx":696 * cdef int x1, x2, y1, y2 * weightsarr = np.array([[0.35355339, 0.4472136, 0.5, 0.4472136, 0.35355339], * [0.4472136, 0.70710678, 1., 0.70710678, 0.4472136], # <<<<<<<<<<<<<< * [0.5, 1., 0., 1., 0.5], * [0.4472136, 0.70710678, 1., 0.70710678, 0.4472136], */ __pyx_t_3 = PyList_New(5); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 696, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __Pyx_INCREF(__pyx_float_0_4472136); __Pyx_GIVEREF(__pyx_float_0_4472136); if (__Pyx_PyList_SET_ITEM(__pyx_t_3, 0, __pyx_float_0_4472136)) __PYX_ERR(0, 696, __pyx_L1_error); __Pyx_INCREF(__pyx_float_0_70710678); __Pyx_GIVEREF(__pyx_float_0_70710678); if (__Pyx_PyList_SET_ITEM(__pyx_t_3, 1, __pyx_float_0_70710678)) __PYX_ERR(0, 696, __pyx_L1_error); __Pyx_INCREF(__pyx_float_1_); __Pyx_GIVEREF(__pyx_float_1_); if (__Pyx_PyList_SET_ITEM(__pyx_t_3, 2, __pyx_float_1_)) __PYX_ERR(0, 696, __pyx_L1_error); __Pyx_INCREF(__pyx_float_0_70710678); __Pyx_GIVEREF(__pyx_float_0_70710678); if (__Pyx_PyList_SET_ITEM(__pyx_t_3, 3, __pyx_float_0_70710678)) __PYX_ERR(0, 696, __pyx_L1_error); __Pyx_INCREF(__pyx_float_0_4472136); __Pyx_GIVEREF(__pyx_float_0_4472136); if (__Pyx_PyList_SET_ITEM(__pyx_t_3, 4, __pyx_float_0_4472136)) __PYX_ERR(0, 696, __pyx_L1_error); /* "astroscrappy/astroscrappy.pyx":697 * weightsarr = np.array([[0.35355339, 0.4472136, 0.5, 0.4472136, 0.35355339], * [0.4472136, 0.70710678, 1., 0.70710678, 0.4472136], * [0.5, 1., 0., 1., 0.5], # <<<<<<<<<<<<<< * [0.4472136, 0.70710678, 1., 0.70710678, 0.4472136], * [0.35355339, 0.4472136, 0.5, 0.4472136, 0.35355339]], */ __pyx_t_4 = PyList_New(5); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 697, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __Pyx_INCREF(__pyx_float_0_5); __Pyx_GIVEREF(__pyx_float_0_5); if (__Pyx_PyList_SET_ITEM(__pyx_t_4, 0, __pyx_float_0_5)) __PYX_ERR(0, 697, __pyx_L1_error); __Pyx_INCREF(__pyx_float_1_); __Pyx_GIVEREF(__pyx_float_1_); if (__Pyx_PyList_SET_ITEM(__pyx_t_4, 1, __pyx_float_1_)) __PYX_ERR(0, 697, __pyx_L1_error); __Pyx_INCREF(__pyx_float_0_); __Pyx_GIVEREF(__pyx_float_0_); if (__Pyx_PyList_SET_ITEM(__pyx_t_4, 2, __pyx_float_0_)) __PYX_ERR(0, 697, __pyx_L1_error); __Pyx_INCREF(__pyx_float_1_); __Pyx_GIVEREF(__pyx_float_1_); if (__Pyx_PyList_SET_ITEM(__pyx_t_4, 3, __pyx_float_1_)) __PYX_ERR(0, 697, __pyx_L1_error); __Pyx_INCREF(__pyx_float_0_5); __Pyx_GIVEREF(__pyx_float_0_5); if (__Pyx_PyList_SET_ITEM(__pyx_t_4, 4, __pyx_float_0_5)) __PYX_ERR(0, 697, __pyx_L1_error); /* "astroscrappy/astroscrappy.pyx":698 * [0.4472136, 0.70710678, 1., 0.70710678, 0.4472136], * [0.5, 1., 0., 1., 0.5], * [0.4472136, 0.70710678, 1., 0.70710678, 0.4472136], # <<<<<<<<<<<<<< * [0.35355339, 0.4472136, 0.5, 0.4472136, 0.35355339]], * dtype=np.float32) */ __pyx_t_5 = PyList_New(5); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 698, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_5); __Pyx_INCREF(__pyx_float_0_4472136); __Pyx_GIVEREF(__pyx_float_0_4472136); if (__Pyx_PyList_SET_ITEM(__pyx_t_5, 0, __pyx_float_0_4472136)) __PYX_ERR(0, 698, __pyx_L1_error); __Pyx_INCREF(__pyx_float_0_70710678); __Pyx_GIVEREF(__pyx_float_0_70710678); if (__Pyx_PyList_SET_ITEM(__pyx_t_5, 1, __pyx_float_0_70710678)) __PYX_ERR(0, 698, __pyx_L1_error); __Pyx_INCREF(__pyx_float_1_); __Pyx_GIVEREF(__pyx_float_1_); if (__Pyx_PyList_SET_ITEM(__pyx_t_5, 2, __pyx_float_1_)) __PYX_ERR(0, 698, __pyx_L1_error); __Pyx_INCREF(__pyx_float_0_70710678); __Pyx_GIVEREF(__pyx_float_0_70710678); if (__Pyx_PyList_SET_ITEM(__pyx_t_5, 3, __pyx_float_0_70710678)) __PYX_ERR(0, 698, __pyx_L1_error); __Pyx_INCREF(__pyx_float_0_4472136); __Pyx_GIVEREF(__pyx_float_0_4472136); if (__Pyx_PyList_SET_ITEM(__pyx_t_5, 4, __pyx_float_0_4472136)) __PYX_ERR(0, 698, __pyx_L1_error); /* "astroscrappy/astroscrappy.pyx":699 * [0.5, 1., 0., 1., 0.5], * [0.4472136, 0.70710678, 1., 0.70710678, 0.4472136], * [0.35355339, 0.4472136, 0.5, 0.4472136, 0.35355339]], # <<<<<<<<<<<<<< * dtype=np.float32) * cdef float[:, ::1] weights = weightsarr */ __pyx_t_6 = PyList_New(5); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 699, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); __Pyx_INCREF(__pyx_float_0_35355339); __Pyx_GIVEREF(__pyx_float_0_35355339); if (__Pyx_PyList_SET_ITEM(__pyx_t_6, 0, __pyx_float_0_35355339)) __PYX_ERR(0, 699, __pyx_L1_error); __Pyx_INCREF(__pyx_float_0_4472136); __Pyx_GIVEREF(__pyx_float_0_4472136); if (__Pyx_PyList_SET_ITEM(__pyx_t_6, 1, __pyx_float_0_4472136)) __PYX_ERR(0, 699, __pyx_L1_error); __Pyx_INCREF(__pyx_float_0_5); __Pyx_GIVEREF(__pyx_float_0_5); if (__Pyx_PyList_SET_ITEM(__pyx_t_6, 2, __pyx_float_0_5)) __PYX_ERR(0, 699, __pyx_L1_error); __Pyx_INCREF(__pyx_float_0_4472136); __Pyx_GIVEREF(__pyx_float_0_4472136); if (__Pyx_PyList_SET_ITEM(__pyx_t_6, 3, __pyx_float_0_4472136)) __PYX_ERR(0, 699, __pyx_L1_error); __Pyx_INCREF(__pyx_float_0_35355339); __Pyx_GIVEREF(__pyx_float_0_35355339); if (__Pyx_PyList_SET_ITEM(__pyx_t_6, 4, __pyx_float_0_35355339)) __PYX_ERR(0, 699, __pyx_L1_error); /* "astroscrappy/astroscrappy.pyx":695 * cdef float f11, f12, f21, f22 = background_level * cdef int x1, x2, y1, y2 * weightsarr = np.array([[0.35355339, 0.4472136, 0.5, 0.4472136, 0.35355339], # <<<<<<<<<<<<<< * [0.4472136, 0.70710678, 1., 0.70710678, 0.4472136], * [0.5, 1., 0., 1., 0.5], */ __pyx_t_7 = PyList_New(5); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 695, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_7); __Pyx_GIVEREF(__pyx_t_1); if (__Pyx_PyList_SET_ITEM(__pyx_t_7, 0, __pyx_t_1)) __PYX_ERR(0, 695, __pyx_L1_error); __Pyx_GIVEREF(__pyx_t_3); if (__Pyx_PyList_SET_ITEM(__pyx_t_7, 1, __pyx_t_3)) __PYX_ERR(0, 695, __pyx_L1_error); __Pyx_GIVEREF(__pyx_t_4); if (__Pyx_PyList_SET_ITEM(__pyx_t_7, 2, __pyx_t_4)) __PYX_ERR(0, 695, __pyx_L1_error); __Pyx_GIVEREF(__pyx_t_5); if (__Pyx_PyList_SET_ITEM(__pyx_t_7, 3, __pyx_t_5)) __PYX_ERR(0, 695, __pyx_L1_error); __Pyx_GIVEREF(__pyx_t_6); if (__Pyx_PyList_SET_ITEM(__pyx_t_7, 4, __pyx_t_6)) __PYX_ERR(0, 695, __pyx_L1_error); __pyx_t_1 = 0; __pyx_t_3 = 0; __pyx_t_4 = 0; __pyx_t_5 = 0; __pyx_t_6 = 0; __pyx_t_6 = PyTuple_New(1); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 695, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); __Pyx_GIVEREF(__pyx_t_7); if (__Pyx_PyTuple_SET_ITEM(__pyx_t_6, 0, __pyx_t_7)) __PYX_ERR(0, 695, __pyx_L1_error); __pyx_t_7 = 0; /* "astroscrappy/astroscrappy.pyx":700 * [0.4472136, 0.70710678, 1., 0.70710678, 0.4472136], * [0.35355339, 0.4472136, 0.5, 0.4472136, 0.35355339]], * dtype=np.float32) # <<<<<<<<<<<<<< * cdef float[:, ::1] weights = weightsarr * cdef float wsum */ __pyx_t_7 = __Pyx_PyDict_NewPresized(1); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 700, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_7); __Pyx_GetModuleGlobalName(__pyx_t_5, __pyx_n_s_np); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 700, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_5); __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_t_5, __pyx_n_s_float32); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 700, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; if (PyDict_SetItem(__pyx_t_7, __pyx_n_s_dtype, __pyx_t_4) < 0) __PYX_ERR(0, 700, __pyx_L1_error) __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; /* "astroscrappy/astroscrappy.pyx":695 * cdef float f11, f12, f21, f22 = background_level * cdef int x1, x2, y1, y2 * weightsarr = np.array([[0.35355339, 0.4472136, 0.5, 0.4472136, 0.35355339], # <<<<<<<<<<<<<< * [0.4472136, 0.70710678, 1., 0.70710678, 0.4472136], * [0.5, 1., 0., 1., 0.5], */ __pyx_t_4 = __Pyx_PyObject_Call(__pyx_t_2, __pyx_t_6, __pyx_t_7); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 695, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; __pyx_v_weightsarr = __pyx_t_4; __pyx_t_4 = 0; /* "astroscrappy/astroscrappy.pyx":701 * [0.35355339, 0.4472136, 0.5, 0.4472136, 0.35355339]], * dtype=np.float32) * cdef float[:, ::1] weights = weightsarr # <<<<<<<<<<<<<< * cdef float wsum * cdef float val */ __pyx_t_8 = __Pyx_PyObject_to_MemoryviewSlice_d_dc_float(__pyx_v_weightsarr, PyBUF_WRITABLE); if (unlikely(!__pyx_t_8.memview)) __PYX_ERR(0, 701, __pyx_L1_error) __pyx_v_weights = __pyx_t_8; __pyx_t_8.memview = NULL; __pyx_t_8.data = NULL; /* "astroscrappy/astroscrappy.pyx":706 * cdef int x, y * # For each pixel * with nogil, parallel(): # <<<<<<<<<<<<<< * * for j in prange(2, ny - 2): */ { #ifdef WITH_THREAD PyThreadState *_save; _save = NULL; Py_UNBLOCK_THREADS __Pyx_FastGIL_Remember(); #endif /*try:*/ { { #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 #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_18, __pyx_t_19, __pyx_t_20, __pyx_t_21, __pyx_t_22, __pyx_t_9) #endif /* _OPENMP */ { /* "astroscrappy/astroscrappy.pyx":708 * with nogil, parallel(): * * for j in prange(2, ny - 2): # <<<<<<<<<<<<<< * for i in range(2, nx - 2): * # if the pixel is in the crmask */ __pyx_t_9 = (__pyx_v_ny - 2); { __pyx_t_11 = (__pyx_t_9 - 2 + 1 - 1/abs(1)) / 1; if (__pyx_t_11 > 0) { #ifdef _OPENMP #pragma omp for lastprivate(__pyx_v_i) firstprivate(__pyx_v_j) lastprivate(__pyx_v_j) lastprivate(__pyx_v_k) lastprivate(__pyx_v_l) lastprivate(__pyx_v_val) lastprivate(__pyx_v_wsum) lastprivate(__pyx_v_x) lastprivate(__pyx_v_y) #endif /* _OPENMP */ for (__pyx_t_10 = 0; __pyx_t_10 < __pyx_t_11; __pyx_t_10++){ { __pyx_v_j = (int)(2 + 1 * __pyx_t_10); /* Initialize private variables to invalid values */ __pyx_v_i = ((int)0xbad0bad0); __pyx_v_k = ((int)0xbad0bad0); __pyx_v_l = ((int)0xbad0bad0); __pyx_v_val = ((float)__PYX_NAN()); __pyx_v_wsum = ((float)__PYX_NAN()); __pyx_v_x = ((int)0xbad0bad0); __pyx_v_y = ((int)0xbad0bad0); /* "astroscrappy/astroscrappy.pyx":709 * * for j in prange(2, ny - 2): * for i in range(2, nx - 2): # <<<<<<<<<<<<<< * # if the pixel is in the crmask * if crmask[j, i]: */ __pyx_t_12 = (__pyx_v_nx - 2); __pyx_t_13 = __pyx_t_12; for (__pyx_t_14 = 2; __pyx_t_14 < __pyx_t_13; __pyx_t_14+=1) { __pyx_v_i = __pyx_t_14; /* "astroscrappy/astroscrappy.pyx":711 * for i in range(2, nx - 2): * # if the pixel is in the crmask * if crmask[j, i]: # <<<<<<<<<<<<<< * wsum = 0.0 * val = 0.0 */ __pyx_t_15 = __pyx_v_j; __pyx_t_16 = __pyx_v_i; __pyx_t_17 = ((*((__pyx_t_12astroscrappy_12astroscrappy_bool *) ( /* dim=1 */ ((char *) (((__pyx_t_12astroscrappy_12astroscrappy_bool *) ( /* dim=0 */ (__pyx_v_crmask.data + __pyx_t_15 * __pyx_v_crmask.strides[0]) )) + __pyx_t_16)) ))) != 0); if (__pyx_t_17) { /* "astroscrappy/astroscrappy.pyx":712 * # if the pixel is in the crmask * if crmask[j, i]: * wsum = 0.0 # <<<<<<<<<<<<<< * val = 0.0 * for l in range(-2, 3): */ __pyx_v_wsum = 0.0; /* "astroscrappy/astroscrappy.pyx":713 * if crmask[j, i]: * wsum = 0.0 * val = 0.0 # <<<<<<<<<<<<<< * for l in range(-2, 3): * y = j + l */ __pyx_v_val = 0.0; /* "astroscrappy/astroscrappy.pyx":714 * wsum = 0.0 * val = 0.0 * for l in range(-2, 3): # <<<<<<<<<<<<<< * y = j + l * for k in range(-2, 3): */ for (__pyx_t_18 = -2; __pyx_t_18 < 3; __pyx_t_18+=1) { __pyx_v_l = __pyx_t_18; /* "astroscrappy/astroscrappy.pyx":715 * val = 0.0 * for l in range(-2, 3): * y = j + l # <<<<<<<<<<<<<< * for k in range(-2, 3): * x = i + k */ __pyx_v_y = (__pyx_v_j + __pyx_v_l); /* "astroscrappy/astroscrappy.pyx":716 * for l in range(-2, 3): * y = j + l * for k in range(-2, 3): # <<<<<<<<<<<<<< * x = i + k * if not (crmask[y, x] or mask[y, x]): */ for (__pyx_t_19 = -2; __pyx_t_19 < 3; __pyx_t_19+=1) { __pyx_v_k = __pyx_t_19; /* "astroscrappy/astroscrappy.pyx":717 * y = j + l * for k in range(-2, 3): * x = i + k # <<<<<<<<<<<<<< * if not (crmask[y, x] or mask[y, x]): * val = val + weights[l+2, k+2] * cleanarr[y, x] */ __pyx_v_x = (__pyx_v_i + __pyx_v_k); /* "astroscrappy/astroscrappy.pyx":718 * for k in range(-2, 3): * x = i + k * if not (crmask[y, x] or mask[y, x]): # <<<<<<<<<<<<<< * val = val + weights[l+2, k+2] * cleanarr[y, x] * wsum = wsum + weights[l+2, k+2] */ __pyx_t_16 = __pyx_v_y; __pyx_t_15 = __pyx_v_x; __pyx_t_20 = ((*((__pyx_t_12astroscrappy_12astroscrappy_bool *) ( /* dim=1 */ ((char *) (((__pyx_t_12astroscrappy_12astroscrappy_bool *) ( /* dim=0 */ (__pyx_v_crmask.data + __pyx_t_16 * __pyx_v_crmask.strides[0]) )) + __pyx_t_15)) ))) != 0); if (!__pyx_t_20) { } else { __pyx_t_17 = __pyx_t_20; goto __pyx_L22_bool_binop_done; } __pyx_t_15 = __pyx_v_y; __pyx_t_16 = __pyx_v_x; __pyx_t_20 = ((*((__pyx_t_12astroscrappy_12astroscrappy_bool *) ( /* dim=1 */ ((char *) (((__pyx_t_12astroscrappy_12astroscrappy_bool *) ( /* dim=0 */ (__pyx_v_mask.data + __pyx_t_15 * __pyx_v_mask.strides[0]) )) + __pyx_t_16)) ))) != 0); __pyx_t_17 = __pyx_t_20; __pyx_L22_bool_binop_done:; __pyx_t_20 = (!__pyx_t_17); if (__pyx_t_20) { /* "astroscrappy/astroscrappy.pyx":719 * x = i + k * if not (crmask[y, x] or mask[y, x]): * val = val + weights[l+2, k+2] * cleanarr[y, x] # <<<<<<<<<<<<<< * wsum = wsum + weights[l+2, k+2] * if wsum < 1e-6: */ __pyx_t_16 = (__pyx_v_l + 2); __pyx_t_15 = (__pyx_v_k + 2); __pyx_t_21 = __pyx_v_y; __pyx_t_22 = __pyx_v_x; __pyx_v_val = (__pyx_v_val + ((*((float *) ( /* dim=1 */ ((char *) (((float *) ( /* dim=0 */ (__pyx_v_weights.data + __pyx_t_16 * __pyx_v_weights.strides[0]) )) + __pyx_t_15)) ))) * (*((float *) ( /* dim=1 */ ((char *) (((float *) ( /* dim=0 */ (__pyx_v_cleanarr.data + __pyx_t_21 * __pyx_v_cleanarr.strides[0]) )) + __pyx_t_22)) ))))); /* "astroscrappy/astroscrappy.pyx":720 * if not (crmask[y, x] or mask[y, x]): * val = val + weights[l+2, k+2] * cleanarr[y, x] * wsum = wsum + weights[l+2, k+2] # <<<<<<<<<<<<<< * if wsum < 1e-6: * cleanarr[j, i] = background_level */ __pyx_t_22 = (__pyx_v_l + 2); __pyx_t_21 = (__pyx_v_k + 2); __pyx_v_wsum = (__pyx_v_wsum + (*((float *) ( /* dim=1 */ ((char *) (((float *) ( /* dim=0 */ (__pyx_v_weights.data + __pyx_t_22 * __pyx_v_weights.strides[0]) )) + __pyx_t_21)) )))); /* "astroscrappy/astroscrappy.pyx":718 * for k in range(-2, 3): * x = i + k * if not (crmask[y, x] or mask[y, x]): # <<<<<<<<<<<<<< * val = val + weights[l+2, k+2] * cleanarr[y, x] * wsum = wsum + weights[l+2, k+2] */ } } } /* "astroscrappy/astroscrappy.pyx":721 * val = val + weights[l+2, k+2] * cleanarr[y, x] * wsum = wsum + weights[l+2, k+2] * if wsum < 1e-6: # <<<<<<<<<<<<<< * cleanarr[j, i] = background_level * else: */ __pyx_t_20 = (__pyx_v_wsum < 1e-6); if (__pyx_t_20) { /* "astroscrappy/astroscrappy.pyx":722 * wsum = wsum + weights[l+2, k+2] * if wsum < 1e-6: * cleanarr[j, i] = background_level # <<<<<<<<<<<<<< * else: * cleanarr[j, i] = val / wsum */ __pyx_t_21 = __pyx_v_j; __pyx_t_22 = __pyx_v_i; *((float *) ( /* dim=1 */ ((char *) (((float *) ( /* dim=0 */ (__pyx_v_cleanarr.data + __pyx_t_21 * __pyx_v_cleanarr.strides[0]) )) + __pyx_t_22)) )) = __pyx_v_background_level; /* "astroscrappy/astroscrappy.pyx":721 * val = val + weights[l+2, k+2] * cleanarr[y, x] * wsum = wsum + weights[l+2, k+2] * if wsum < 1e-6: # <<<<<<<<<<<<<< * cleanarr[j, i] = background_level * else: */ goto __pyx_L24; } /* "astroscrappy/astroscrappy.pyx":724 * cleanarr[j, i] = background_level * else: * cleanarr[j, i] = val / wsum # <<<<<<<<<<<<<< * * */ /*else*/ { __pyx_t_22 = __pyx_v_j; __pyx_t_21 = __pyx_v_i; *((float *) ( /* dim=1 */ ((char *) (((float *) ( /* dim=0 */ (__pyx_v_cleanarr.data + __pyx_t_22 * __pyx_v_cleanarr.strides[0]) )) + __pyx_t_21)) )) = (__pyx_v_val / __pyx_v_wsum); } __pyx_L24:; /* "astroscrappy/astroscrappy.pyx":711 * for i in range(2, nx - 2): * # if the pixel is in the crmask * if crmask[j, i]: # <<<<<<<<<<<<<< * wsum = 0.0 * val = 0.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 } /* "astroscrappy/astroscrappy.pyx":706 * cdef int x, y * # For each pixel * with nogil, parallel(): # <<<<<<<<<<<<<< * * for j in prange(2, ny - 2): */ /*finally:*/ { /*normal exit:*/{ #ifdef WITH_THREAD __Pyx_FastGIL_Forget(); Py_BLOCK_THREADS #endif goto __pyx_L5; } __pyx_L5:; } } /* "astroscrappy/astroscrappy.pyx":659 * * * cdef void clean_idwinterp(float[:, ::1] cleanarr, bool[:, ::1] crmask, # <<<<<<<<<<<<<< * bool[:, ::1] mask, int nx, int ny, * float background_level): */ /* 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_7); __PYX_XCLEAR_MEMVIEW(&__pyx_t_8, 1); __Pyx_AddTraceback("astroscrappy.astroscrappy.clean_idwinterp", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_L0:; __Pyx_XDECREF(__pyx_v_weightsarr); __PYX_XCLEAR_MEMVIEW(&__pyx_v_weights, 1); __Pyx_RefNannyFinishContext(); } /* "astroscrappy/astroscrappy.pyx":727 * * * def gausskernel(float psffwhm, int kernsize): # <<<<<<<<<<<<<< * """gausskernel(psffwhm, kernsize)\n * Calculate a circular Gaussian psf kernel. */ /* Python wrapper */ static PyObject *__pyx_pw_12astroscrappy_12astroscrappy_5gausskernel(PyObject *__pyx_self, #if CYTHON_METH_FASTCALL PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds #else PyObject *__pyx_args, PyObject *__pyx_kwds #endif ); /*proto*/ PyDoc_STRVAR(__pyx_doc_12astroscrappy_12astroscrappy_4gausskernel, "gausskernel(psffwhm, kernsize)\n\n Calculate a circular Gaussian psf kernel.\n\n Parameters\n ----------\n psffwhm : float\n Full Width Half Maximum of the PSF to use to generate the kernel.\n\n kernsize : int\n Size of the kernel to calculate. kernsize should be odd.\n Returned kernel will have size kernsize x kernsize.\n\n Returns\n -------\n kernel : float numpy array\n Gaussian PSF kernel with size kernsize x kernsize.\n "); static PyMethodDef __pyx_mdef_12astroscrappy_12astroscrappy_5gausskernel = {"gausskernel", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_12astroscrappy_12astroscrappy_5gausskernel, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_12astroscrappy_12astroscrappy_4gausskernel}; static PyObject *__pyx_pw_12astroscrappy_12astroscrappy_5gausskernel(PyObject *__pyx_self, #if CYTHON_METH_FASTCALL PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds #else PyObject *__pyx_args, PyObject *__pyx_kwds #endif ) { float __pyx_v_psffwhm; int __pyx_v_kernsize; #if !CYTHON_METH_FASTCALL CYTHON_UNUSED Py_ssize_t __pyx_nargs; #endif CYTHON_UNUSED PyObject *const *__pyx_kwvalues; PyObject* values[2] = {0,0}; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("gausskernel (wrapper)", 0); #if !CYTHON_METH_FASTCALL #if CYTHON_ASSUME_SAFE_MACROS __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); #else __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; #endif #endif __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); { PyObject **__pyx_pyargnames[] = {&__pyx_n_s_psffwhm,&__pyx_n_s_kernsize,0}; if (__pyx_kwds) { Py_ssize_t kw_args; switch (__pyx_nargs) { case 2: values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); CYTHON_FALLTHROUGH; case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); CYTHON_FALLTHROUGH; case 0: break; default: goto __pyx_L5_argtuple_error; } kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); switch (__pyx_nargs) { case 0: if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_psffwhm)) != 0)) { (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); kw_args--; } else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 727, __pyx_L3_error) else goto __pyx_L5_argtuple_error; CYTHON_FALLTHROUGH; case 1: if (likely((values[1] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_kernsize)) != 0)) { (void)__Pyx_Arg_NewRef_FASTCALL(values[1]); kw_args--; } else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 727, __pyx_L3_error) else { __Pyx_RaiseArgtupleInvalid("gausskernel", 1, 2, 2, 1); __PYX_ERR(0, 727, __pyx_L3_error) } } if (unlikely(kw_args > 0)) { const Py_ssize_t kwd_pos_args = __pyx_nargs; if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "gausskernel") < 0)) __PYX_ERR(0, 727, __pyx_L3_error) } } else if (unlikely(__pyx_nargs != 2)) { goto __pyx_L5_argtuple_error; } else { values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); } __pyx_v_psffwhm = __pyx_PyFloat_AsFloat(values[0]); if (unlikely((__pyx_v_psffwhm == (float)-1) && PyErr_Occurred())) __PYX_ERR(0, 727, __pyx_L3_error) __pyx_v_kernsize = __Pyx_PyInt_As_int(values[1]); if (unlikely((__pyx_v_kernsize == (int)-1) && PyErr_Occurred())) __PYX_ERR(0, 727, __pyx_L3_error) } goto __pyx_L6_skip; __pyx_L5_argtuple_error:; __Pyx_RaiseArgtupleInvalid("gausskernel", 1, 2, 2, __pyx_nargs); __PYX_ERR(0, 727, __pyx_L3_error) __pyx_L6_skip:; goto __pyx_L4_argument_unpacking_done; __pyx_L3_error:; { Py_ssize_t __pyx_temp; for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); } } __Pyx_AddTraceback("astroscrappy.astroscrappy.gausskernel", __pyx_clineno, __pyx_lineno, __pyx_filename); __Pyx_RefNannyFinishContext(); return NULL; __pyx_L4_argument_unpacking_done:; __pyx_r = __pyx_pf_12astroscrappy_12astroscrappy_4gausskernel(__pyx_self, __pyx_v_psffwhm, __pyx_v_kernsize); /* function exit code */ { Py_ssize_t __pyx_temp; for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); } } __Pyx_RefNannyFinishContext(); return __pyx_r; } static PyObject *__pyx_pf_12astroscrappy_12astroscrappy_4gausskernel(CYTHON_UNUSED PyObject *__pyx_self, float __pyx_v_psffwhm, int __pyx_v_kernsize) { PyObject *__pyx_v_kernel = NULL; PyObject *__pyx_v_x = NULL; PyObject *__pyx_v_y = NULL; PyObject *__pyx_v_r2 = NULL; double __pyx_v_sigma2; 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; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("gausskernel", 1); /* "astroscrappy/astroscrappy.pyx":745 * Gaussian PSF kernel with size kernsize x kernsize. * """ * kernel = np.zeros((kernsize, kernsize), dtype=np.float32) # <<<<<<<<<<<<<< * # Make a grid of x and y values * x = np.tile(np.arange(kernsize) - kernsize / 2, (kernsize, 1)) */ __Pyx_GetModuleGlobalName(__pyx_t_1, __pyx_n_s_np); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 745, __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, 745, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __pyx_t_1 = __Pyx_PyInt_From_int(__pyx_v_kernsize); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 745, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_t_3 = __Pyx_PyInt_From_int(__pyx_v_kernsize); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 745, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __pyx_t_4 = PyTuple_New(2); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 745, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __Pyx_GIVEREF(__pyx_t_1); if (__Pyx_PyTuple_SET_ITEM(__pyx_t_4, 0, __pyx_t_1)) __PYX_ERR(0, 745, __pyx_L1_error); __Pyx_GIVEREF(__pyx_t_3); if (__Pyx_PyTuple_SET_ITEM(__pyx_t_4, 1, __pyx_t_3)) __PYX_ERR(0, 745, __pyx_L1_error); __pyx_t_1 = 0; __pyx_t_3 = 0; __pyx_t_3 = PyTuple_New(1); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 745, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __Pyx_GIVEREF(__pyx_t_4); if (__Pyx_PyTuple_SET_ITEM(__pyx_t_3, 0, __pyx_t_4)) __PYX_ERR(0, 745, __pyx_L1_error); __pyx_t_4 = 0; __pyx_t_4 = __Pyx_PyDict_NewPresized(1); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 745, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __Pyx_GetModuleGlobalName(__pyx_t_1, __pyx_n_s_np); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 745, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_t_1, __pyx_n_s_float32); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 745, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_5); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; if (PyDict_SetItem(__pyx_t_4, __pyx_n_s_dtype, __pyx_t_5) < 0) __PYX_ERR(0, 745, __pyx_L1_error) __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; __pyx_t_5 = __Pyx_PyObject_Call(__pyx_t_2, __pyx_t_3, __pyx_t_4); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 745, __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_DECREF(__pyx_t_4); __pyx_t_4 = 0; __pyx_v_kernel = __pyx_t_5; __pyx_t_5 = 0; /* "astroscrappy/astroscrappy.pyx":747 * kernel = np.zeros((kernsize, kernsize), dtype=np.float32) * # Make a grid of x and y values * x = np.tile(np.arange(kernsize) - kernsize / 2, (kernsize, 1)) # <<<<<<<<<<<<<< * y = x.transpose().copy() * # Calculate the offset, r */ __Pyx_GetModuleGlobalName(__pyx_t_4, __pyx_n_s_np); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 747, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_t_4, __pyx_n_s_tile); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 747, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_np); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 747, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_t_2, __pyx_n_s_arange); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 747, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; __pyx_t_2 = __Pyx_PyInt_From_int(__pyx_v_kernsize); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 747, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __pyx_t_6 = NULL; __pyx_t_7 = 0; #if CYTHON_UNPACK_METHODS if (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_7 = 1; } } #endif { PyObject *__pyx_callargs[2] = {__pyx_t_6, __pyx_t_2}; __pyx_t_4 = __Pyx_PyObject_FastCall(__pyx_t_1, __pyx_callargs+1-__pyx_t_7, 1+__pyx_t_7); __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0; __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 747, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; } __pyx_t_1 = __Pyx_PyInt_From_long((((long)__pyx_v_kernsize) / 2)); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 747, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_t_2 = PyNumber_Subtract(__pyx_t_4, __pyx_t_1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 747, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __pyx_t_1 = __Pyx_PyInt_From_int(__pyx_v_kernsize); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 747, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_t_4 = PyTuple_New(2); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 747, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __Pyx_GIVEREF(__pyx_t_1); if (__Pyx_PyTuple_SET_ITEM(__pyx_t_4, 0, __pyx_t_1)) __PYX_ERR(0, 747, __pyx_L1_error); __Pyx_INCREF(__pyx_int_1); __Pyx_GIVEREF(__pyx_int_1); if (__Pyx_PyTuple_SET_ITEM(__pyx_t_4, 1, __pyx_int_1)) __PYX_ERR(0, 747, __pyx_L1_error); __pyx_t_1 = 0; __pyx_t_1 = NULL; __pyx_t_7 = 0; #if CYTHON_UNPACK_METHODS if (unlikely(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_7 = 1; } } #endif { PyObject *__pyx_callargs[3] = {__pyx_t_1, __pyx_t_2, __pyx_t_4}; __pyx_t_5 = __Pyx_PyObject_FastCall(__pyx_t_3, __pyx_callargs+1-__pyx_t_7, 2+__pyx_t_7); __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0; __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 747, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_5); __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; } __pyx_v_x = __pyx_t_5; __pyx_t_5 = 0; /* "astroscrappy/astroscrappy.pyx":748 * # Make a grid of x and y values * x = np.tile(np.arange(kernsize) - kernsize / 2, (kernsize, 1)) * y = x.transpose().copy() # <<<<<<<<<<<<<< * # Calculate the offset, r * r2 = x * x + y * y */ __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_v_x, __pyx_n_s_transpose); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 748, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __pyx_t_2 = NULL; __pyx_t_7 = 0; #if CYTHON_UNPACK_METHODS if (likely(PyMethod_Check(__pyx_t_4))) { __pyx_t_2 = PyMethod_GET_SELF(__pyx_t_4); if (likely(__pyx_t_2)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_4); __Pyx_INCREF(__pyx_t_2); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_4, function); __pyx_t_7 = 1; } } #endif { PyObject *__pyx_callargs[2] = {__pyx_t_2, NULL}; __pyx_t_3 = __Pyx_PyObject_FastCall(__pyx_t_4, __pyx_callargs+1-__pyx_t_7, 0+__pyx_t_7); __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0; if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 748, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; } __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_t_3, __pyx_n_s_copy); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 748, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; __pyx_t_3 = NULL; __pyx_t_7 = 0; #if CYTHON_UNPACK_METHODS if (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_7 = 1; } } #endif { PyObject *__pyx_callargs[2] = {__pyx_t_3, NULL}; __pyx_t_5 = __Pyx_PyObject_FastCall(__pyx_t_4, __pyx_callargs+1-__pyx_t_7, 0+__pyx_t_7); __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 748, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_5); __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; } __pyx_v_y = __pyx_t_5; __pyx_t_5 = 0; /* "astroscrappy/astroscrappy.pyx":750 * y = x.transpose().copy() * # Calculate the offset, r * r2 = x * x + y * y # <<<<<<<<<<<<<< * # Calculate the kernel * sigma2 = psffwhm * psffwhm / 2.35482 / 2.35482 */ __pyx_t_5 = PyNumber_Multiply(__pyx_v_x, __pyx_v_x); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 750, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_5); __pyx_t_4 = PyNumber_Multiply(__pyx_v_y, __pyx_v_y); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 750, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __pyx_t_3 = PyNumber_Add(__pyx_t_5, __pyx_t_4); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 750, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __pyx_v_r2 = __pyx_t_3; __pyx_t_3 = 0; /* "astroscrappy/astroscrappy.pyx":752 * r2 = x * x + y * y * # Calculate the kernel * sigma2 = psffwhm * psffwhm / 2.35482 / 2.35482 # <<<<<<<<<<<<<< * kernel[:, :] = np.exp(-0.5 * r2 / sigma2)[:, :] * # Normalize the kernel */ __pyx_v_sigma2 = ((((double)(__pyx_v_psffwhm * __pyx_v_psffwhm)) / 2.35482) / 2.35482); /* "astroscrappy/astroscrappy.pyx":753 * # Calculate the kernel * sigma2 = psffwhm * psffwhm / 2.35482 / 2.35482 * kernel[:, :] = np.exp(-0.5 * r2 / sigma2)[:, :] # <<<<<<<<<<<<<< * # Normalize the kernel * kernel /= kernel.sum() */ __Pyx_GetModuleGlobalName(__pyx_t_4, __pyx_n_s_np); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 753, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_t_4, __pyx_n_s_exp); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 753, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_5); __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __pyx_t_4 = PyNumber_Multiply(__pyx_float_neg_0_5, __pyx_v_r2); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 753, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __pyx_t_2 = PyFloat_FromDouble(__pyx_v_sigma2); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 753, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __pyx_t_1 = __Pyx_PyNumber_Divide(__pyx_t_4, __pyx_t_2); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 753, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; __pyx_t_2 = NULL; __pyx_t_7 = 0; #if CYTHON_UNPACK_METHODS if (unlikely(PyMethod_Check(__pyx_t_5))) { __pyx_t_2 = PyMethod_GET_SELF(__pyx_t_5); if (likely(__pyx_t_2)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_5); __Pyx_INCREF(__pyx_t_2); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_5, function); __pyx_t_7 = 1; } } #endif { PyObject *__pyx_callargs[2] = {__pyx_t_2, __pyx_t_1}; __pyx_t_3 = __Pyx_PyObject_FastCall(__pyx_t_5, __pyx_callargs+1-__pyx_t_7, 1+__pyx_t_7); __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0; __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 753, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; } __pyx_t_5 = __Pyx_PyObject_GetItem(__pyx_t_3, __pyx_tuple__11); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 753, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_5); __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; if (unlikely((PyObject_SetItem(__pyx_v_kernel, __pyx_tuple__11, __pyx_t_5) < 0))) __PYX_ERR(0, 753, __pyx_L1_error) __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; /* "astroscrappy/astroscrappy.pyx":755 * kernel[:, :] = np.exp(-0.5 * r2 / sigma2)[:, :] * # Normalize the kernel * kernel /= kernel.sum() # <<<<<<<<<<<<<< * return kernel * */ __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_v_kernel, __pyx_n_s_sum); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 755, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __pyx_t_1 = NULL; __pyx_t_7 = 0; #if CYTHON_UNPACK_METHODS if (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_7 = 1; } } #endif { PyObject *__pyx_callargs[2] = {__pyx_t_1, NULL}; __pyx_t_5 = __Pyx_PyObject_FastCall(__pyx_t_3, __pyx_callargs+1-__pyx_t_7, 0+__pyx_t_7); __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0; if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 755, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_5); __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; } __pyx_t_3 = __Pyx_PyNumber_InPlaceDivide(__pyx_v_kernel, __pyx_t_5); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 755, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; __Pyx_DECREF_SET(__pyx_v_kernel, __pyx_t_3); __pyx_t_3 = 0; /* "astroscrappy/astroscrappy.pyx":756 * # Normalize the kernel * kernel /= kernel.sum() * return kernel # <<<<<<<<<<<<<< * * */ __Pyx_XDECREF(__pyx_r); __Pyx_INCREF(__pyx_v_kernel); __pyx_r = __pyx_v_kernel; goto __pyx_L0; /* "astroscrappy/astroscrappy.pyx":727 * * * def gausskernel(float psffwhm, int kernsize): # <<<<<<<<<<<<<< * """gausskernel(psffwhm, kernsize)\n * Calculate a circular Gaussian psf kernel. */ /* 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_AddTraceback("astroscrappy.astroscrappy.gausskernel", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __pyx_L0:; __Pyx_XDECREF(__pyx_v_kernel); __Pyx_XDECREF(__pyx_v_x); __Pyx_XDECREF(__pyx_v_y); __Pyx_XDECREF(__pyx_v_r2); __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "astroscrappy/astroscrappy.pyx":759 * * * def gaussxkernel(float psffwhm, int kernsize): # <<<<<<<<<<<<<< * """gaussxkernel(psffwhm, kernsize)\n * Calculate a Gaussian kernel in the x-direction. */ /* Python wrapper */ static PyObject *__pyx_pw_12astroscrappy_12astroscrappy_7gaussxkernel(PyObject *__pyx_self, #if CYTHON_METH_FASTCALL PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds #else PyObject *__pyx_args, PyObject *__pyx_kwds #endif ); /*proto*/ PyDoc_STRVAR(__pyx_doc_12astroscrappy_12astroscrappy_6gaussxkernel, "gaussxkernel(psffwhm, kernsize)\n\n Calculate a Gaussian kernel in the x-direction.\n\n This can be used for spectroscopic data.\n\n Parameters\n ----------\n psffwhm : float\n Full Width Half Maximum of the PSF to use to generate the kernel.\n\n kernsize : int\n Size of the kernel to calculate. kernsize should be odd.\n Returned kernel will have size kernsize x kernsize.\n\n Returns\n -------\n kernel : float numpy array\n Gaussian(x) kernel with size kernsize x kernsize.\n "); static PyMethodDef __pyx_mdef_12astroscrappy_12astroscrappy_7gaussxkernel = {"gaussxkernel", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_12astroscrappy_12astroscrappy_7gaussxkernel, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_12astroscrappy_12astroscrappy_6gaussxkernel}; static PyObject *__pyx_pw_12astroscrappy_12astroscrappy_7gaussxkernel(PyObject *__pyx_self, #if CYTHON_METH_FASTCALL PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds #else PyObject *__pyx_args, PyObject *__pyx_kwds #endif ) { float __pyx_v_psffwhm; int __pyx_v_kernsize; #if !CYTHON_METH_FASTCALL CYTHON_UNUSED Py_ssize_t __pyx_nargs; #endif CYTHON_UNUSED PyObject *const *__pyx_kwvalues; PyObject* values[2] = {0,0}; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("gaussxkernel (wrapper)", 0); #if !CYTHON_METH_FASTCALL #if CYTHON_ASSUME_SAFE_MACROS __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); #else __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; #endif #endif __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); { PyObject **__pyx_pyargnames[] = {&__pyx_n_s_psffwhm,&__pyx_n_s_kernsize,0}; if (__pyx_kwds) { Py_ssize_t kw_args; switch (__pyx_nargs) { case 2: values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); CYTHON_FALLTHROUGH; case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); CYTHON_FALLTHROUGH; case 0: break; default: goto __pyx_L5_argtuple_error; } kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); switch (__pyx_nargs) { case 0: if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_psffwhm)) != 0)) { (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); kw_args--; } else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 759, __pyx_L3_error) else goto __pyx_L5_argtuple_error; CYTHON_FALLTHROUGH; case 1: if (likely((values[1] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_kernsize)) != 0)) { (void)__Pyx_Arg_NewRef_FASTCALL(values[1]); kw_args--; } else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 759, __pyx_L3_error) else { __Pyx_RaiseArgtupleInvalid("gaussxkernel", 1, 2, 2, 1); __PYX_ERR(0, 759, __pyx_L3_error) } } if (unlikely(kw_args > 0)) { const Py_ssize_t kwd_pos_args = __pyx_nargs; if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "gaussxkernel") < 0)) __PYX_ERR(0, 759, __pyx_L3_error) } } else if (unlikely(__pyx_nargs != 2)) { goto __pyx_L5_argtuple_error; } else { values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); } __pyx_v_psffwhm = __pyx_PyFloat_AsFloat(values[0]); if (unlikely((__pyx_v_psffwhm == (float)-1) && PyErr_Occurred())) __PYX_ERR(0, 759, __pyx_L3_error) __pyx_v_kernsize = __Pyx_PyInt_As_int(values[1]); if (unlikely((__pyx_v_kernsize == (int)-1) && PyErr_Occurred())) __PYX_ERR(0, 759, __pyx_L3_error) } goto __pyx_L6_skip; __pyx_L5_argtuple_error:; __Pyx_RaiseArgtupleInvalid("gaussxkernel", 1, 2, 2, __pyx_nargs); __PYX_ERR(0, 759, __pyx_L3_error) __pyx_L6_skip:; goto __pyx_L4_argument_unpacking_done; __pyx_L3_error:; { Py_ssize_t __pyx_temp; for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); } } __Pyx_AddTraceback("astroscrappy.astroscrappy.gaussxkernel", __pyx_clineno, __pyx_lineno, __pyx_filename); __Pyx_RefNannyFinishContext(); return NULL; __pyx_L4_argument_unpacking_done:; __pyx_r = __pyx_pf_12astroscrappy_12astroscrappy_6gaussxkernel(__pyx_self, __pyx_v_psffwhm, __pyx_v_kernsize); /* function exit code */ { Py_ssize_t __pyx_temp; for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); } } __Pyx_RefNannyFinishContext(); return __pyx_r; } static PyObject *__pyx_pf_12astroscrappy_12astroscrappy_6gaussxkernel(CYTHON_UNUSED PyObject *__pyx_self, float __pyx_v_psffwhm, int __pyx_v_kernsize) { PyObject *__pyx_v_kernel = NULL; PyObject *__pyx_v_x = NULL; double __pyx_v_sigma2; 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; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("gaussxkernel", 1); /* "astroscrappy/astroscrappy.pyx":779 * Gaussian(x) kernel with size kernsize x kernsize. * """ * kernel = np.zeros((kernsize, kernsize), dtype=np.float32) # <<<<<<<<<<<<<< * # Make a grid of x and y values * x = np.tile(np.arange(kernsize) - kernsize / 2, (kernsize, 1)) */ __Pyx_GetModuleGlobalName(__pyx_t_1, __pyx_n_s_np); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 779, __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, 779, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __pyx_t_1 = __Pyx_PyInt_From_int(__pyx_v_kernsize); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 779, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_t_3 = __Pyx_PyInt_From_int(__pyx_v_kernsize); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 779, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __pyx_t_4 = PyTuple_New(2); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 779, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __Pyx_GIVEREF(__pyx_t_1); if (__Pyx_PyTuple_SET_ITEM(__pyx_t_4, 0, __pyx_t_1)) __PYX_ERR(0, 779, __pyx_L1_error); __Pyx_GIVEREF(__pyx_t_3); if (__Pyx_PyTuple_SET_ITEM(__pyx_t_4, 1, __pyx_t_3)) __PYX_ERR(0, 779, __pyx_L1_error); __pyx_t_1 = 0; __pyx_t_3 = 0; __pyx_t_3 = PyTuple_New(1); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 779, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __Pyx_GIVEREF(__pyx_t_4); if (__Pyx_PyTuple_SET_ITEM(__pyx_t_3, 0, __pyx_t_4)) __PYX_ERR(0, 779, __pyx_L1_error); __pyx_t_4 = 0; __pyx_t_4 = __Pyx_PyDict_NewPresized(1); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 779, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __Pyx_GetModuleGlobalName(__pyx_t_1, __pyx_n_s_np); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 779, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_t_1, __pyx_n_s_float32); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 779, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_5); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; if (PyDict_SetItem(__pyx_t_4, __pyx_n_s_dtype, __pyx_t_5) < 0) __PYX_ERR(0, 779, __pyx_L1_error) __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; __pyx_t_5 = __Pyx_PyObject_Call(__pyx_t_2, __pyx_t_3, __pyx_t_4); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 779, __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_DECREF(__pyx_t_4); __pyx_t_4 = 0; __pyx_v_kernel = __pyx_t_5; __pyx_t_5 = 0; /* "astroscrappy/astroscrappy.pyx":781 * kernel = np.zeros((kernsize, kernsize), dtype=np.float32) * # Make a grid of x and y values * x = np.tile(np.arange(kernsize) - kernsize / 2, (kernsize, 1)) # <<<<<<<<<<<<<< * # Calculate the kernel * sigma2 = psffwhm * psffwhm / 2.35482 / 2.35482 */ __Pyx_GetModuleGlobalName(__pyx_t_4, __pyx_n_s_np); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 781, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_t_4, __pyx_n_s_tile); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 781, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_np); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 781, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_t_2, __pyx_n_s_arange); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 781, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; __pyx_t_2 = __Pyx_PyInt_From_int(__pyx_v_kernsize); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 781, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __pyx_t_6 = NULL; __pyx_t_7 = 0; #if CYTHON_UNPACK_METHODS if (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_7 = 1; } } #endif { PyObject *__pyx_callargs[2] = {__pyx_t_6, __pyx_t_2}; __pyx_t_4 = __Pyx_PyObject_FastCall(__pyx_t_1, __pyx_callargs+1-__pyx_t_7, 1+__pyx_t_7); __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0; __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 781, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; } __pyx_t_1 = __Pyx_PyInt_From_long((((long)__pyx_v_kernsize) / 2)); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 781, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_t_2 = PyNumber_Subtract(__pyx_t_4, __pyx_t_1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 781, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __pyx_t_1 = __Pyx_PyInt_From_int(__pyx_v_kernsize); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 781, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_t_4 = PyTuple_New(2); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 781, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __Pyx_GIVEREF(__pyx_t_1); if (__Pyx_PyTuple_SET_ITEM(__pyx_t_4, 0, __pyx_t_1)) __PYX_ERR(0, 781, __pyx_L1_error); __Pyx_INCREF(__pyx_int_1); __Pyx_GIVEREF(__pyx_int_1); if (__Pyx_PyTuple_SET_ITEM(__pyx_t_4, 1, __pyx_int_1)) __PYX_ERR(0, 781, __pyx_L1_error); __pyx_t_1 = 0; __pyx_t_1 = NULL; __pyx_t_7 = 0; #if CYTHON_UNPACK_METHODS if (unlikely(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_7 = 1; } } #endif { PyObject *__pyx_callargs[3] = {__pyx_t_1, __pyx_t_2, __pyx_t_4}; __pyx_t_5 = __Pyx_PyObject_FastCall(__pyx_t_3, __pyx_callargs+1-__pyx_t_7, 2+__pyx_t_7); __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0; __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 781, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_5); __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; } __pyx_v_x = __pyx_t_5; __pyx_t_5 = 0; /* "astroscrappy/astroscrappy.pyx":783 * x = np.tile(np.arange(kernsize) - kernsize / 2, (kernsize, 1)) * # Calculate the kernel * sigma2 = psffwhm * psffwhm / 2.35482 / 2.35482 # <<<<<<<<<<<<<< * kernel[:, :] = np.exp(-0.5 * x * x / sigma2)[:, :] * # Normalize the kernel */ __pyx_v_sigma2 = ((((double)(__pyx_v_psffwhm * __pyx_v_psffwhm)) / 2.35482) / 2.35482); /* "astroscrappy/astroscrappy.pyx":784 * # Calculate the kernel * sigma2 = psffwhm * psffwhm / 2.35482 / 2.35482 * kernel[:, :] = np.exp(-0.5 * x * x / sigma2)[:, :] # <<<<<<<<<<<<<< * # Normalize the kernel * kernel /= kernel.sum() */ __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_n_s_np); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 784, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_t_3, __pyx_n_s_exp); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 784, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; __pyx_t_3 = PyNumber_Multiply(__pyx_float_neg_0_5, __pyx_v_x); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 784, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __pyx_t_2 = PyNumber_Multiply(__pyx_t_3, __pyx_v_x); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 784, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; __pyx_t_3 = PyFloat_FromDouble(__pyx_v_sigma2); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 784, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __pyx_t_1 = __Pyx_PyNumber_Divide(__pyx_t_2, __pyx_t_3); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 784, __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_t_3 = NULL; __pyx_t_7 = 0; #if CYTHON_UNPACK_METHODS if (unlikely(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_7 = 1; } } #endif { PyObject *__pyx_callargs[2] = {__pyx_t_3, __pyx_t_1}; __pyx_t_5 = __Pyx_PyObject_FastCall(__pyx_t_4, __pyx_callargs+1-__pyx_t_7, 1+__pyx_t_7); __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 784, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_5); __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; } __pyx_t_4 = __Pyx_PyObject_GetItem(__pyx_t_5, __pyx_tuple__11); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 784, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; if (unlikely((PyObject_SetItem(__pyx_v_kernel, __pyx_tuple__11, __pyx_t_4) < 0))) __PYX_ERR(0, 784, __pyx_L1_error) __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; /* "astroscrappy/astroscrappy.pyx":786 * kernel[:, :] = np.exp(-0.5 * x * x / sigma2)[:, :] * # Normalize the kernel * kernel /= kernel.sum() # <<<<<<<<<<<<<< * return kernel * */ __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_v_kernel, __pyx_n_s_sum); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 786, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_5); __pyx_t_1 = NULL; __pyx_t_7 = 0; #if CYTHON_UNPACK_METHODS if (likely(PyMethod_Check(__pyx_t_5))) { __pyx_t_1 = PyMethod_GET_SELF(__pyx_t_5); if (likely(__pyx_t_1)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_5); __Pyx_INCREF(__pyx_t_1); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_5, function); __pyx_t_7 = 1; } } #endif { PyObject *__pyx_callargs[2] = {__pyx_t_1, NULL}; __pyx_t_4 = __Pyx_PyObject_FastCall(__pyx_t_5, __pyx_callargs+1-__pyx_t_7, 0+__pyx_t_7); __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0; if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 786, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; } __pyx_t_5 = __Pyx_PyNumber_InPlaceDivide(__pyx_v_kernel, __pyx_t_4); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 786, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_5); __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __Pyx_DECREF_SET(__pyx_v_kernel, __pyx_t_5); __pyx_t_5 = 0; /* "astroscrappy/astroscrappy.pyx":787 * # Normalize the kernel * kernel /= kernel.sum() * return kernel # <<<<<<<<<<<<<< * * */ __Pyx_XDECREF(__pyx_r); __Pyx_INCREF(__pyx_v_kernel); __pyx_r = __pyx_v_kernel; goto __pyx_L0; /* "astroscrappy/astroscrappy.pyx":759 * * * def gaussxkernel(float psffwhm, int kernsize): # <<<<<<<<<<<<<< * """gaussxkernel(psffwhm, kernsize)\n * Calculate a Gaussian kernel in the x-direction. */ /* 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_AddTraceback("astroscrappy.astroscrappy.gaussxkernel", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __pyx_L0:; __Pyx_XDECREF(__pyx_v_kernel); __Pyx_XDECREF(__pyx_v_x); __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "astroscrappy/astroscrappy.pyx":790 * * * def gaussykernel(float psffwhm, int kernsize): # <<<<<<<<<<<<<< * """gaussykernel(psffwhm, kernsize)\n * Calculate a Gaussian kernel in the y-direction. */ /* Python wrapper */ static PyObject *__pyx_pw_12astroscrappy_12astroscrappy_9gaussykernel(PyObject *__pyx_self, #if CYTHON_METH_FASTCALL PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds #else PyObject *__pyx_args, PyObject *__pyx_kwds #endif ); /*proto*/ PyDoc_STRVAR(__pyx_doc_12astroscrappy_12astroscrappy_8gaussykernel, "gaussykernel(psffwhm, kernsize)\n\n Calculate a Gaussian kernel in the y-direction.\n\n This can be used for spectroscopic data.\n\n Parameters\n ----------\n psffwhm : float\n Full Width Half Maximum of the PSF to use to generate the kernel.\n\n kernsize : int\n Size of the kernel to calculate. kernsize should be odd.\n Returned kernel will have size kernsize x kernsize.\n\n Returns\n -------\n kernel : float numpy array\n Gaussian(y) kernel with size kernsize x kernsize.\n "); static PyMethodDef __pyx_mdef_12astroscrappy_12astroscrappy_9gaussykernel = {"gaussykernel", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_12astroscrappy_12astroscrappy_9gaussykernel, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_12astroscrappy_12astroscrappy_8gaussykernel}; static PyObject *__pyx_pw_12astroscrappy_12astroscrappy_9gaussykernel(PyObject *__pyx_self, #if CYTHON_METH_FASTCALL PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds #else PyObject *__pyx_args, PyObject *__pyx_kwds #endif ) { float __pyx_v_psffwhm; int __pyx_v_kernsize; #if !CYTHON_METH_FASTCALL CYTHON_UNUSED Py_ssize_t __pyx_nargs; #endif CYTHON_UNUSED PyObject *const *__pyx_kwvalues; PyObject* values[2] = {0,0}; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("gaussykernel (wrapper)", 0); #if !CYTHON_METH_FASTCALL #if CYTHON_ASSUME_SAFE_MACROS __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); #else __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; #endif #endif __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); { PyObject **__pyx_pyargnames[] = {&__pyx_n_s_psffwhm,&__pyx_n_s_kernsize,0}; if (__pyx_kwds) { Py_ssize_t kw_args; switch (__pyx_nargs) { case 2: values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); CYTHON_FALLTHROUGH; case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); CYTHON_FALLTHROUGH; case 0: break; default: goto __pyx_L5_argtuple_error; } kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); switch (__pyx_nargs) { case 0: if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_psffwhm)) != 0)) { (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); kw_args--; } else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 790, __pyx_L3_error) else goto __pyx_L5_argtuple_error; CYTHON_FALLTHROUGH; case 1: if (likely((values[1] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_kernsize)) != 0)) { (void)__Pyx_Arg_NewRef_FASTCALL(values[1]); kw_args--; } else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 790, __pyx_L3_error) else { __Pyx_RaiseArgtupleInvalid("gaussykernel", 1, 2, 2, 1); __PYX_ERR(0, 790, __pyx_L3_error) } } if (unlikely(kw_args > 0)) { const Py_ssize_t kwd_pos_args = __pyx_nargs; if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "gaussykernel") < 0)) __PYX_ERR(0, 790, __pyx_L3_error) } } else if (unlikely(__pyx_nargs != 2)) { goto __pyx_L5_argtuple_error; } else { values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); } __pyx_v_psffwhm = __pyx_PyFloat_AsFloat(values[0]); if (unlikely((__pyx_v_psffwhm == (float)-1) && PyErr_Occurred())) __PYX_ERR(0, 790, __pyx_L3_error) __pyx_v_kernsize = __Pyx_PyInt_As_int(values[1]); if (unlikely((__pyx_v_kernsize == (int)-1) && PyErr_Occurred())) __PYX_ERR(0, 790, __pyx_L3_error) } goto __pyx_L6_skip; __pyx_L5_argtuple_error:; __Pyx_RaiseArgtupleInvalid("gaussykernel", 1, 2, 2, __pyx_nargs); __PYX_ERR(0, 790, __pyx_L3_error) __pyx_L6_skip:; goto __pyx_L4_argument_unpacking_done; __pyx_L3_error:; { Py_ssize_t __pyx_temp; for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); } } __Pyx_AddTraceback("astroscrappy.astroscrappy.gaussykernel", __pyx_clineno, __pyx_lineno, __pyx_filename); __Pyx_RefNannyFinishContext(); return NULL; __pyx_L4_argument_unpacking_done:; __pyx_r = __pyx_pf_12astroscrappy_12astroscrappy_8gaussykernel(__pyx_self, __pyx_v_psffwhm, __pyx_v_kernsize); /* function exit code */ { Py_ssize_t __pyx_temp; for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); } } __Pyx_RefNannyFinishContext(); return __pyx_r; } static PyObject *__pyx_pf_12astroscrappy_12astroscrappy_8gaussykernel(CYTHON_UNUSED PyObject *__pyx_self, float __pyx_v_psffwhm, int __pyx_v_kernsize) { PyObject *__pyx_v_kernel = NULL; PyObject *__pyx_v_x = NULL; PyObject *__pyx_v_y = NULL; double __pyx_v_sigma2; 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; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("gaussykernel", 1); /* "astroscrappy/astroscrappy.pyx":810 * Gaussian(y) kernel with size kernsize x kernsize. * """ * kernel = np.zeros((kernsize, kernsize), dtype=np.float32) # <<<<<<<<<<<<<< * # Make a grid of x and y values * x = np.tile(np.arange(kernsize) - kernsize / 2, (kernsize, 1)) */ __Pyx_GetModuleGlobalName(__pyx_t_1, __pyx_n_s_np); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 810, __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, 810, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __pyx_t_1 = __Pyx_PyInt_From_int(__pyx_v_kernsize); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 810, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_t_3 = __Pyx_PyInt_From_int(__pyx_v_kernsize); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 810, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __pyx_t_4 = PyTuple_New(2); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 810, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __Pyx_GIVEREF(__pyx_t_1); if (__Pyx_PyTuple_SET_ITEM(__pyx_t_4, 0, __pyx_t_1)) __PYX_ERR(0, 810, __pyx_L1_error); __Pyx_GIVEREF(__pyx_t_3); if (__Pyx_PyTuple_SET_ITEM(__pyx_t_4, 1, __pyx_t_3)) __PYX_ERR(0, 810, __pyx_L1_error); __pyx_t_1 = 0; __pyx_t_3 = 0; __pyx_t_3 = PyTuple_New(1); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 810, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __Pyx_GIVEREF(__pyx_t_4); if (__Pyx_PyTuple_SET_ITEM(__pyx_t_3, 0, __pyx_t_4)) __PYX_ERR(0, 810, __pyx_L1_error); __pyx_t_4 = 0; __pyx_t_4 = __Pyx_PyDict_NewPresized(1); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 810, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __Pyx_GetModuleGlobalName(__pyx_t_1, __pyx_n_s_np); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 810, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_t_1, __pyx_n_s_float32); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 810, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_5); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; if (PyDict_SetItem(__pyx_t_4, __pyx_n_s_dtype, __pyx_t_5) < 0) __PYX_ERR(0, 810, __pyx_L1_error) __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; __pyx_t_5 = __Pyx_PyObject_Call(__pyx_t_2, __pyx_t_3, __pyx_t_4); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 810, __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_DECREF(__pyx_t_4); __pyx_t_4 = 0; __pyx_v_kernel = __pyx_t_5; __pyx_t_5 = 0; /* "astroscrappy/astroscrappy.pyx":812 * kernel = np.zeros((kernsize, kernsize), dtype=np.float32) * # Make a grid of x and y values * x = np.tile(np.arange(kernsize) - kernsize / 2, (kernsize, 1)) # <<<<<<<<<<<<<< * y = x.transpose().copy() * # Calculate the kernel */ __Pyx_GetModuleGlobalName(__pyx_t_4, __pyx_n_s_np); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 812, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_t_4, __pyx_n_s_tile); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 812, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_np); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 812, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_t_2, __pyx_n_s_arange); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 812, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; __pyx_t_2 = __Pyx_PyInt_From_int(__pyx_v_kernsize); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 812, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __pyx_t_6 = NULL; __pyx_t_7 = 0; #if CYTHON_UNPACK_METHODS if (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_7 = 1; } } #endif { PyObject *__pyx_callargs[2] = {__pyx_t_6, __pyx_t_2}; __pyx_t_4 = __Pyx_PyObject_FastCall(__pyx_t_1, __pyx_callargs+1-__pyx_t_7, 1+__pyx_t_7); __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0; __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 812, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; } __pyx_t_1 = __Pyx_PyInt_From_long((((long)__pyx_v_kernsize) / 2)); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 812, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_t_2 = PyNumber_Subtract(__pyx_t_4, __pyx_t_1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 812, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __pyx_t_1 = __Pyx_PyInt_From_int(__pyx_v_kernsize); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 812, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_t_4 = PyTuple_New(2); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 812, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __Pyx_GIVEREF(__pyx_t_1); if (__Pyx_PyTuple_SET_ITEM(__pyx_t_4, 0, __pyx_t_1)) __PYX_ERR(0, 812, __pyx_L1_error); __Pyx_INCREF(__pyx_int_1); __Pyx_GIVEREF(__pyx_int_1); if (__Pyx_PyTuple_SET_ITEM(__pyx_t_4, 1, __pyx_int_1)) __PYX_ERR(0, 812, __pyx_L1_error); __pyx_t_1 = 0; __pyx_t_1 = NULL; __pyx_t_7 = 0; #if CYTHON_UNPACK_METHODS if (unlikely(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_7 = 1; } } #endif { PyObject *__pyx_callargs[3] = {__pyx_t_1, __pyx_t_2, __pyx_t_4}; __pyx_t_5 = __Pyx_PyObject_FastCall(__pyx_t_3, __pyx_callargs+1-__pyx_t_7, 2+__pyx_t_7); __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0; __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 812, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_5); __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; } __pyx_v_x = __pyx_t_5; __pyx_t_5 = 0; /* "astroscrappy/astroscrappy.pyx":813 * # Make a grid of x and y values * x = np.tile(np.arange(kernsize) - kernsize / 2, (kernsize, 1)) * y = x.transpose().copy() # <<<<<<<<<<<<<< * # Calculate the kernel * sigma2 = psffwhm * psffwhm / 2.35482 / 2.35482 */ __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_v_x, __pyx_n_s_transpose); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 813, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __pyx_t_2 = NULL; __pyx_t_7 = 0; #if CYTHON_UNPACK_METHODS if (likely(PyMethod_Check(__pyx_t_4))) { __pyx_t_2 = PyMethod_GET_SELF(__pyx_t_4); if (likely(__pyx_t_2)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_4); __Pyx_INCREF(__pyx_t_2); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_4, function); __pyx_t_7 = 1; } } #endif { PyObject *__pyx_callargs[2] = {__pyx_t_2, NULL}; __pyx_t_3 = __Pyx_PyObject_FastCall(__pyx_t_4, __pyx_callargs+1-__pyx_t_7, 0+__pyx_t_7); __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0; if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 813, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; } __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_t_3, __pyx_n_s_copy); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 813, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; __pyx_t_3 = NULL; __pyx_t_7 = 0; #if CYTHON_UNPACK_METHODS if (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_7 = 1; } } #endif { PyObject *__pyx_callargs[2] = {__pyx_t_3, NULL}; __pyx_t_5 = __Pyx_PyObject_FastCall(__pyx_t_4, __pyx_callargs+1-__pyx_t_7, 0+__pyx_t_7); __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 813, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_5); __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; } __pyx_v_y = __pyx_t_5; __pyx_t_5 = 0; /* "astroscrappy/astroscrappy.pyx":815 * y = x.transpose().copy() * # Calculate the kernel * sigma2 = psffwhm * psffwhm / 2.35482 / 2.35482 # <<<<<<<<<<<<<< * kernel[:, :] = np.exp(-0.5 * y * y / sigma2)[:, :] * # Normalize the kernel */ __pyx_v_sigma2 = ((((double)(__pyx_v_psffwhm * __pyx_v_psffwhm)) / 2.35482) / 2.35482); /* "astroscrappy/astroscrappy.pyx":816 * # Calculate the kernel * sigma2 = psffwhm * psffwhm / 2.35482 / 2.35482 * kernel[:, :] = np.exp(-0.5 * y * y / sigma2)[:, :] # <<<<<<<<<<<<<< * # Normalize the kernel * kernel /= kernel.sum() */ __Pyx_GetModuleGlobalName(__pyx_t_4, __pyx_n_s_np); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 816, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_t_4, __pyx_n_s_exp); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 816, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __pyx_t_4 = PyNumber_Multiply(__pyx_float_neg_0_5, __pyx_v_y); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 816, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __pyx_t_2 = PyNumber_Multiply(__pyx_t_4, __pyx_v_y); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 816, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __pyx_t_4 = PyFloat_FromDouble(__pyx_v_sigma2); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 816, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __pyx_t_1 = __Pyx_PyNumber_Divide(__pyx_t_2, __pyx_t_4); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 816, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __pyx_t_4 = NULL; __pyx_t_7 = 0; #if CYTHON_UNPACK_METHODS if (unlikely(PyMethod_Check(__pyx_t_3))) { __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_3); if (likely(__pyx_t_4)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3); __Pyx_INCREF(__pyx_t_4); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_3, function); __pyx_t_7 = 1; } } #endif { PyObject *__pyx_callargs[2] = {__pyx_t_4, __pyx_t_1}; __pyx_t_5 = __Pyx_PyObject_FastCall(__pyx_t_3, __pyx_callargs+1-__pyx_t_7, 1+__pyx_t_7); __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 816, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_5); __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; } __pyx_t_3 = __Pyx_PyObject_GetItem(__pyx_t_5, __pyx_tuple__11); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 816, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; if (unlikely((PyObject_SetItem(__pyx_v_kernel, __pyx_tuple__11, __pyx_t_3) < 0))) __PYX_ERR(0, 816, __pyx_L1_error) __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; /* "astroscrappy/astroscrappy.pyx":818 * kernel[:, :] = np.exp(-0.5 * y * y / sigma2)[:, :] * # Normalize the kernel * kernel /= kernel.sum() # <<<<<<<<<<<<<< * return kernel * */ __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_v_kernel, __pyx_n_s_sum); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 818, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_5); __pyx_t_1 = NULL; __pyx_t_7 = 0; #if CYTHON_UNPACK_METHODS if (likely(PyMethod_Check(__pyx_t_5))) { __pyx_t_1 = PyMethod_GET_SELF(__pyx_t_5); if (likely(__pyx_t_1)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_5); __Pyx_INCREF(__pyx_t_1); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_5, function); __pyx_t_7 = 1; } } #endif { PyObject *__pyx_callargs[2] = {__pyx_t_1, NULL}; __pyx_t_3 = __Pyx_PyObject_FastCall(__pyx_t_5, __pyx_callargs+1-__pyx_t_7, 0+__pyx_t_7); __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0; if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 818, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; } __pyx_t_5 = __Pyx_PyNumber_InPlaceDivide(__pyx_v_kernel, __pyx_t_3); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 818, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_5); __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; __Pyx_DECREF_SET(__pyx_v_kernel, __pyx_t_5); __pyx_t_5 = 0; /* "astroscrappy/astroscrappy.pyx":819 * # Normalize the kernel * kernel /= kernel.sum() * return kernel # <<<<<<<<<<<<<< * * */ __Pyx_XDECREF(__pyx_r); __Pyx_INCREF(__pyx_v_kernel); __pyx_r = __pyx_v_kernel; goto __pyx_L0; /* "astroscrappy/astroscrappy.pyx":790 * * * def gaussykernel(float psffwhm, int kernsize): # <<<<<<<<<<<<<< * """gaussykernel(psffwhm, kernsize)\n * Calculate a Gaussian kernel in the y-direction. */ /* 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_AddTraceback("astroscrappy.astroscrappy.gaussykernel", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __pyx_L0:; __Pyx_XDECREF(__pyx_v_kernel); __Pyx_XDECREF(__pyx_v_x); __Pyx_XDECREF(__pyx_v_y); __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "astroscrappy/astroscrappy.pyx":822 * * * cdef moffatkernel(float psffwhm, float beta, int kernsize): # <<<<<<<<<<<<<< * """moffatkernel(psffwhm, beta, kernsize)\n * Calculate a Moffat psf kernel. */ static PyObject *__pyx_f_12astroscrappy_12astroscrappy_moffatkernel(float __pyx_v_psffwhm, float __pyx_v_beta, int __pyx_v_kernsize) { PyObject *__pyx_v_kernel = NULL; PyObject *__pyx_v_x = NULL; PyObject *__pyx_v_y = NULL; PyObject *__pyx_v_r = NULL; double __pyx_v_hwhm; PyObject *__pyx_v_alpha = 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; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("moffatkernel", 1); /* "astroscrappy/astroscrappy.pyx":843 * Moffat kernel with size kernsize x kernsize. * """ * kernel = np.zeros((kernsize, kernsize), dtype=np.float32) # <<<<<<<<<<<<<< * # Make a grid of x and y values * x = np.tile(np.arange(kernsize) - kernsize / 2, (kernsize, 1)) */ __Pyx_GetModuleGlobalName(__pyx_t_1, __pyx_n_s_np); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 843, __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, 843, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __pyx_t_1 = __Pyx_PyInt_From_int(__pyx_v_kernsize); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 843, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_t_3 = __Pyx_PyInt_From_int(__pyx_v_kernsize); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 843, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __pyx_t_4 = PyTuple_New(2); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 843, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __Pyx_GIVEREF(__pyx_t_1); if (__Pyx_PyTuple_SET_ITEM(__pyx_t_4, 0, __pyx_t_1)) __PYX_ERR(0, 843, __pyx_L1_error); __Pyx_GIVEREF(__pyx_t_3); if (__Pyx_PyTuple_SET_ITEM(__pyx_t_4, 1, __pyx_t_3)) __PYX_ERR(0, 843, __pyx_L1_error); __pyx_t_1 = 0; __pyx_t_3 = 0; __pyx_t_3 = PyTuple_New(1); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 843, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __Pyx_GIVEREF(__pyx_t_4); if (__Pyx_PyTuple_SET_ITEM(__pyx_t_3, 0, __pyx_t_4)) __PYX_ERR(0, 843, __pyx_L1_error); __pyx_t_4 = 0; __pyx_t_4 = __Pyx_PyDict_NewPresized(1); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 843, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __Pyx_GetModuleGlobalName(__pyx_t_1, __pyx_n_s_np); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 843, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_t_1, __pyx_n_s_float32); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 843, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_5); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; if (PyDict_SetItem(__pyx_t_4, __pyx_n_s_dtype, __pyx_t_5) < 0) __PYX_ERR(0, 843, __pyx_L1_error) __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; __pyx_t_5 = __Pyx_PyObject_Call(__pyx_t_2, __pyx_t_3, __pyx_t_4); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 843, __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_DECREF(__pyx_t_4); __pyx_t_4 = 0; __pyx_v_kernel = __pyx_t_5; __pyx_t_5 = 0; /* "astroscrappy/astroscrappy.pyx":845 * kernel = np.zeros((kernsize, kernsize), dtype=np.float32) * # Make a grid of x and y values * x = np.tile(np.arange(kernsize) - kernsize / 2, (kernsize, 1)) # <<<<<<<<<<<<<< * y = x.transpose().copy() * # Calculate the offset r */ __Pyx_GetModuleGlobalName(__pyx_t_4, __pyx_n_s_np); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 845, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_t_4, __pyx_n_s_tile); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 845, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_np); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 845, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_t_2, __pyx_n_s_arange); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 845, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; __pyx_t_2 = __Pyx_PyInt_From_int(__pyx_v_kernsize); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 845, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __pyx_t_6 = NULL; __pyx_t_7 = 0; #if CYTHON_UNPACK_METHODS if (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_7 = 1; } } #endif { PyObject *__pyx_callargs[2] = {__pyx_t_6, __pyx_t_2}; __pyx_t_4 = __Pyx_PyObject_FastCall(__pyx_t_1, __pyx_callargs+1-__pyx_t_7, 1+__pyx_t_7); __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0; __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 845, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; } __pyx_t_1 = __Pyx_PyInt_From_long((((long)__pyx_v_kernsize) / 2)); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 845, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_t_2 = PyNumber_Subtract(__pyx_t_4, __pyx_t_1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 845, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __pyx_t_1 = __Pyx_PyInt_From_int(__pyx_v_kernsize); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 845, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_t_4 = PyTuple_New(2); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 845, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __Pyx_GIVEREF(__pyx_t_1); if (__Pyx_PyTuple_SET_ITEM(__pyx_t_4, 0, __pyx_t_1)) __PYX_ERR(0, 845, __pyx_L1_error); __Pyx_INCREF(__pyx_int_1); __Pyx_GIVEREF(__pyx_int_1); if (__Pyx_PyTuple_SET_ITEM(__pyx_t_4, 1, __pyx_int_1)) __PYX_ERR(0, 845, __pyx_L1_error); __pyx_t_1 = 0; __pyx_t_1 = NULL; __pyx_t_7 = 0; #if CYTHON_UNPACK_METHODS if (unlikely(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_7 = 1; } } #endif { PyObject *__pyx_callargs[3] = {__pyx_t_1, __pyx_t_2, __pyx_t_4}; __pyx_t_5 = __Pyx_PyObject_FastCall(__pyx_t_3, __pyx_callargs+1-__pyx_t_7, 2+__pyx_t_7); __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0; __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 845, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_5); __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; } __pyx_v_x = __pyx_t_5; __pyx_t_5 = 0; /* "astroscrappy/astroscrappy.pyx":846 * # Make a grid of x and y values * x = np.tile(np.arange(kernsize) - kernsize / 2, (kernsize, 1)) * y = x.transpose().copy() # <<<<<<<<<<<<<< * # Calculate the offset r * r = np.sqrt(x * x + y * y) */ __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_v_x, __pyx_n_s_transpose); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 846, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __pyx_t_2 = NULL; __pyx_t_7 = 0; #if CYTHON_UNPACK_METHODS if (likely(PyMethod_Check(__pyx_t_4))) { __pyx_t_2 = PyMethod_GET_SELF(__pyx_t_4); if (likely(__pyx_t_2)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_4); __Pyx_INCREF(__pyx_t_2); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_4, function); __pyx_t_7 = 1; } } #endif { PyObject *__pyx_callargs[2] = {__pyx_t_2, NULL}; __pyx_t_3 = __Pyx_PyObject_FastCall(__pyx_t_4, __pyx_callargs+1-__pyx_t_7, 0+__pyx_t_7); __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0; if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 846, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; } __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_t_3, __pyx_n_s_copy); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 846, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; __pyx_t_3 = NULL; __pyx_t_7 = 0; #if CYTHON_UNPACK_METHODS if (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_7 = 1; } } #endif { PyObject *__pyx_callargs[2] = {__pyx_t_3, NULL}; __pyx_t_5 = __Pyx_PyObject_FastCall(__pyx_t_4, __pyx_callargs+1-__pyx_t_7, 0+__pyx_t_7); __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 846, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_5); __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; } __pyx_v_y = __pyx_t_5; __pyx_t_5 = 0; /* "astroscrappy/astroscrappy.pyx":848 * y = x.transpose().copy() * # Calculate the offset r * r = np.sqrt(x * x + y * y) # <<<<<<<<<<<<<< * # Calculate the kernel * hwhm = psffwhm / 2.0 */ __Pyx_GetModuleGlobalName(__pyx_t_4, __pyx_n_s_np); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 848, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_t_4, __pyx_n_s_sqrt); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 848, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __pyx_t_4 = PyNumber_Multiply(__pyx_v_x, __pyx_v_x); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 848, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __pyx_t_2 = PyNumber_Multiply(__pyx_v_y, __pyx_v_y); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 848, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __pyx_t_1 = PyNumber_Add(__pyx_t_4, __pyx_t_2); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 848, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; __pyx_t_2 = NULL; __pyx_t_7 = 0; #if CYTHON_UNPACK_METHODS if (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_7 = 1; } } #endif { PyObject *__pyx_callargs[2] = {__pyx_t_2, __pyx_t_1}; __pyx_t_5 = __Pyx_PyObject_FastCall(__pyx_t_3, __pyx_callargs+1-__pyx_t_7, 1+__pyx_t_7); __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0; __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 848, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_5); __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; } __pyx_v_r = __pyx_t_5; __pyx_t_5 = 0; /* "astroscrappy/astroscrappy.pyx":850 * r = np.sqrt(x * x + y * y) * # Calculate the kernel * hwhm = psffwhm / 2.0 # <<<<<<<<<<<<<< * alpha = hwhm / np.sqrt(np.power(2.0, (1.0 / beta)) - 1.0) * kernel[:, :] = (np.power(1.0 + (r * r / alpha / alpha), -1.0 * beta))[:, :] */ __pyx_v_hwhm = (((double)__pyx_v_psffwhm) / 2.0); /* "astroscrappy/astroscrappy.pyx":851 * # Calculate the kernel * hwhm = psffwhm / 2.0 * alpha = hwhm / np.sqrt(np.power(2.0, (1.0 / beta)) - 1.0) # <<<<<<<<<<<<<< * kernel[:, :] = (np.power(1.0 + (r * r / alpha / alpha), -1.0 * beta))[:, :] * # Normalize the kernel. */ __pyx_t_5 = PyFloat_FromDouble(__pyx_v_hwhm); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 851, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_5); __Pyx_GetModuleGlobalName(__pyx_t_1, __pyx_n_s_np); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 851, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_t_1, __pyx_n_s_sqrt); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 851, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __Pyx_GetModuleGlobalName(__pyx_t_4, __pyx_n_s_np); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 851, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_t_4, __pyx_n_s_power); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 851, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __pyx_t_4 = PyFloat_FromDouble((1.0 / ((double)__pyx_v_beta))); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 851, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __pyx_t_8 = NULL; __pyx_t_7 = 0; #if CYTHON_UNPACK_METHODS if (unlikely(PyMethod_Check(__pyx_t_6))) { __pyx_t_8 = PyMethod_GET_SELF(__pyx_t_6); if (likely(__pyx_t_8)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_6); __Pyx_INCREF(__pyx_t_8); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_6, function); __pyx_t_7 = 1; } } #endif { PyObject *__pyx_callargs[3] = {__pyx_t_8, __pyx_float_2_0, __pyx_t_4}; __pyx_t_1 = __Pyx_PyObject_FastCall(__pyx_t_6, __pyx_callargs+1-__pyx_t_7, 2+__pyx_t_7); __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0; __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 851, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; } __pyx_t_6 = __Pyx_PyFloat_SubtractObjC(__pyx_t_1, __pyx_float_1_0, 1.0, 0, 0); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 851, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __pyx_t_1 = NULL; __pyx_t_7 = 0; #if CYTHON_UNPACK_METHODS if (unlikely(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_7 = 1; } } #endif { PyObject *__pyx_callargs[2] = {__pyx_t_1, __pyx_t_6}; __pyx_t_3 = __Pyx_PyObject_FastCall(__pyx_t_2, __pyx_callargs+1-__pyx_t_7, 1+__pyx_t_7); __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0; __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 851, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; } __pyx_t_2 = __Pyx_PyNumber_Divide(__pyx_t_5, __pyx_t_3); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 851, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; __pyx_v_alpha = __pyx_t_2; __pyx_t_2 = 0; /* "astroscrappy/astroscrappy.pyx":852 * hwhm = psffwhm / 2.0 * alpha = hwhm / np.sqrt(np.power(2.0, (1.0 / beta)) - 1.0) * kernel[:, :] = (np.power(1.0 + (r * r / alpha / alpha), -1.0 * beta))[:, :] # <<<<<<<<<<<<<< * # Normalize the kernel. * kernel /= kernel.sum() */ __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_n_s_np); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 852, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_t_3, __pyx_n_s_power); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 852, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_5); __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; __pyx_t_3 = PyNumber_Multiply(__pyx_v_r, __pyx_v_r); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 852, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __pyx_t_6 = __Pyx_PyNumber_Divide(__pyx_t_3, __pyx_v_alpha); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 852, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; __pyx_t_3 = __Pyx_PyNumber_Divide(__pyx_t_6, __pyx_v_alpha); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 852, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; __pyx_t_6 = __Pyx_PyFloat_AddCObj(__pyx_float_1_0, __pyx_t_3, 1.0, 0, 0); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 852, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; __pyx_t_3 = PyFloat_FromDouble((-1.0 * __pyx_v_beta)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 852, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __pyx_t_1 = NULL; __pyx_t_7 = 0; #if CYTHON_UNPACK_METHODS if (unlikely(PyMethod_Check(__pyx_t_5))) { __pyx_t_1 = PyMethod_GET_SELF(__pyx_t_5); if (likely(__pyx_t_1)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_5); __Pyx_INCREF(__pyx_t_1); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_5, function); __pyx_t_7 = 1; } } #endif { PyObject *__pyx_callargs[3] = {__pyx_t_1, __pyx_t_6, __pyx_t_3}; __pyx_t_2 = __Pyx_PyObject_FastCall(__pyx_t_5, __pyx_callargs+1-__pyx_t_7, 2+__pyx_t_7); __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0; __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 852, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; } __pyx_t_5 = __Pyx_PyObject_GetItem(__pyx_t_2, __pyx_tuple__11); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 852, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_5); __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; if (unlikely((PyObject_SetItem(__pyx_v_kernel, __pyx_tuple__11, __pyx_t_5) < 0))) __PYX_ERR(0, 852, __pyx_L1_error) __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; /* "astroscrappy/astroscrappy.pyx":854 * kernel[:, :] = (np.power(1.0 + (r * r / alpha / alpha), -1.0 * beta))[:, :] * # Normalize the kernel. * kernel /= kernel.sum() # <<<<<<<<<<<<<< * return kernel */ __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_v_kernel, __pyx_n_s_sum); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 854, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __pyx_t_3 = NULL; __pyx_t_7 = 0; #if CYTHON_UNPACK_METHODS if (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_7 = 1; } } #endif { PyObject *__pyx_callargs[2] = {__pyx_t_3, NULL}; __pyx_t_5 = __Pyx_PyObject_FastCall(__pyx_t_2, __pyx_callargs+1-__pyx_t_7, 0+__pyx_t_7); __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 854, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_5); __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; } __pyx_t_2 = __Pyx_PyNumber_InPlaceDivide(__pyx_v_kernel, __pyx_t_5); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 854, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; __Pyx_DECREF_SET(__pyx_v_kernel, __pyx_t_2); __pyx_t_2 = 0; /* "astroscrappy/astroscrappy.pyx":855 * # Normalize the kernel. * kernel /= kernel.sum() * return kernel # <<<<<<<<<<<<<< */ __Pyx_XDECREF(__pyx_r); __Pyx_INCREF(__pyx_v_kernel); __pyx_r = __pyx_v_kernel; goto __pyx_L0; /* "astroscrappy/astroscrappy.pyx":822 * * * cdef moffatkernel(float psffwhm, float beta, int kernsize): # <<<<<<<<<<<<<< * """moffatkernel(psffwhm, beta, kernsize)\n * Calculate a Moffat psf kernel. */ /* 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("astroscrappy.astroscrappy.moffatkernel", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = 0; __pyx_L0:; __Pyx_XDECREF(__pyx_v_kernel); __Pyx_XDECREF(__pyx_v_x); __Pyx_XDECREF(__pyx_v_y); __Pyx_XDECREF(__pyx_v_r); __Pyx_XDECREF(__pyx_v_alpha); __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 CYTHON_COMPILING_IN_LIMITED_API allocfunc alloc_func = (allocfunc)PyType_GetSlot(t, Py_tp_alloc); o = alloc_func(t, 0); #else if (likely(!__Pyx_PyType_HasFeature(t, Py_TPFLAGS_IS_ABSTRACT))) { o = (*t->tp_alloc)(t, 0); } else { o = (PyObject *) PyBaseObject_Type.tp_new(t, __pyx_empty_tuple, 0); } if (unlikely(!o)) return 0; #endif 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((PY_VERSION_HEX >= 0x03080000 || __Pyx_PyType_HasFeature(Py_TYPE(o), Py_TPFLAGS_HAVE_FINALIZE)) && __Pyx_PyObject_GetSlot(o, tp_finalize, destructor)) && (!PyType_IS_GC(Py_TYPE(o)) || !__Pyx_PyObject_GC_IsFinalized(o))) { if (__Pyx_PyObject_GetSlot(o, tp_dealloc, destructor) == __pyx_tp_dealloc_array) { 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); #if CYTHON_USE_TYPE_SLOTS || CYTHON_COMPILING_IN_PYPY (*Py_TYPE(o)->tp_free)(o); #else { freefunc tp_free = (freefunc)PyType_GetSlot(Py_TYPE(o), Py_tp_free); if (tp_free) tp_free(o); } #endif } 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 { __Pyx_TypeName o_type_name; o_type_name = __Pyx_PyType_GetName(Py_TYPE(o)); PyErr_Format(PyExc_NotImplementedError, "Subscript deletion not supported by " __Pyx_FMT_TYPENAME, o_type_name); __Pyx_DECREF_TypeName(o_type_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)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw___pyx_array_1__reduce_cython__, __Pyx_METH_FASTCALL|METH_KEYWORDS, 0}, {"__setstate_cython__", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw___pyx_array_3__setstate_cython__, __Pyx_METH_FASTCALL|METH_KEYWORDS, 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} }; #if CYTHON_USE_TYPE_SPECS #if !CYTHON_COMPILING_IN_LIMITED_API 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*/ }; #endif static PyType_Slot __pyx_type___pyx_array_slots[] = { {Py_tp_dealloc, (void *)__pyx_tp_dealloc_array}, {Py_sq_length, (void *)__pyx_array___len__}, {Py_sq_item, (void *)__pyx_sq_item_array}, {Py_mp_length, (void *)__pyx_array___len__}, {Py_mp_subscript, (void *)__pyx_array___getitem__}, {Py_mp_ass_subscript, (void *)__pyx_mp_ass_subscript_array}, {Py_tp_getattro, (void *)__pyx_tp_getattro_array}, #if defined(Py_bf_getbuffer) {Py_bf_getbuffer, (void *)__pyx_array_getbuffer}, #endif {Py_tp_methods, (void *)__pyx_methods_array}, {Py_tp_getset, (void *)__pyx_getsets_array}, {Py_tp_new, (void *)__pyx_tp_new_array}, {0, 0}, }; static PyType_Spec __pyx_type___pyx_array_spec = { "astroscrappy.astroscrappy.array", sizeof(struct __pyx_array_obj), 0, Py_TPFLAGS_DEFAULT|Py_TPFLAGS_HAVE_VERSION_TAG|Py_TPFLAGS_CHECKTYPES|Py_TPFLAGS_HAVE_NEWBUFFER|Py_TPFLAGS_BASETYPE|Py_TPFLAGS_SEQUENCE, __pyx_type___pyx_array_slots, }; #else 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) "astroscrappy.astroscrappy.""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|Py_TPFLAGS_SEQUENCE, /*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*/ #if !CYTHON_USE_TYPE_SPECS 0, /*tp_dictoffset*/ #endif 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 #if CYTHON_USE_TP_FINALIZE 0, /*tp_finalize*/ #else NULL, /*tp_finalize*/ #endif #endif #if PY_VERSION_HEX >= 0x030800b1 && (!CYTHON_COMPILING_IN_PYPY || PYPY_VERSION_NUM >= 0x07030800) 0, /*tp_vectorcall*/ #endif #if __PYX_NEED_TP_PRINT_SLOT == 1 0, /*tp_print*/ #endif #if PY_VERSION_HEX >= 0x030C0000 0, /*tp_watched*/ #endif #if CYTHON_COMPILING_IN_PYPY && PY_VERSION_HEX >= 0x03090000 && PY_VERSION_HEX < 0x030a0000 0, /*tp_pypy_flags*/ #endif }; #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 CYTHON_COMPILING_IN_LIMITED_API allocfunc alloc_func = (allocfunc)PyType_GetSlot(t, Py_tp_alloc); o = alloc_func(t, 0); #else if (likely(!__Pyx_PyType_HasFeature(t, Py_TPFLAGS_IS_ABSTRACT))) { o = (*t->tp_alloc)(t, 0); } else { o = (PyObject *) PyBaseObject_Type.tp_new(t, __pyx_empty_tuple, 0); } if (unlikely(!o)) return 0; #endif 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((PY_VERSION_HEX >= 0x03080000 || __Pyx_PyType_HasFeature(Py_TYPE(o), Py_TPFLAGS_HAVE_FINALIZE)) && __Pyx_PyObject_GetSlot(o, tp_finalize, destructor)) && !__Pyx_PyObject_GC_IsFinalized(o)) { if (__Pyx_PyObject_GetSlot(o, tp_dealloc, destructor) == __pyx_tp_dealloc_Enum) { if (PyObject_CallFinalizerFromDealloc(o)) return; } } #endif PyObject_GC_UnTrack(o); Py_CLEAR(p->name); #if CYTHON_USE_TYPE_SLOTS || CYTHON_COMPILING_IN_PYPY (*Py_TYPE(o)->tp_free)(o); #else { freefunc tp_free = (freefunc)PyType_GetSlot(Py_TYPE(o), Py_tp_free); if (tp_free) tp_free(o); } #endif } 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 PyObject *__pyx_specialmethod___pyx_MemviewEnum___repr__(PyObject *self, CYTHON_UNUSED PyObject *arg) { return __pyx_MemviewEnum___repr__(self); } static PyMethodDef __pyx_methods_Enum[] = { {"__repr__", (PyCFunction)__pyx_specialmethod___pyx_MemviewEnum___repr__, METH_NOARGS|METH_COEXIST, 0}, {"__reduce_cython__", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw___pyx_MemviewEnum_1__reduce_cython__, __Pyx_METH_FASTCALL|METH_KEYWORDS, 0}, {"__setstate_cython__", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw___pyx_MemviewEnum_3__setstate_cython__, __Pyx_METH_FASTCALL|METH_KEYWORDS, 0}, {0, 0, 0, 0} }; #if CYTHON_USE_TYPE_SPECS static PyType_Slot __pyx_type___pyx_MemviewEnum_slots[] = { {Py_tp_dealloc, (void *)__pyx_tp_dealloc_Enum}, {Py_tp_repr, (void *)__pyx_MemviewEnum___repr__}, {Py_tp_traverse, (void *)__pyx_tp_traverse_Enum}, {Py_tp_clear, (void *)__pyx_tp_clear_Enum}, {Py_tp_methods, (void *)__pyx_methods_Enum}, {Py_tp_init, (void *)__pyx_MemviewEnum___init__}, {Py_tp_new, (void *)__pyx_tp_new_Enum}, {0, 0}, }; static PyType_Spec __pyx_type___pyx_MemviewEnum_spec = { "astroscrappy.astroscrappy.Enum", sizeof(struct __pyx_MemviewEnum_obj), 0, Py_TPFLAGS_DEFAULT|Py_TPFLAGS_HAVE_VERSION_TAG|Py_TPFLAGS_CHECKTYPES|Py_TPFLAGS_HAVE_NEWBUFFER|Py_TPFLAGS_BASETYPE|Py_TPFLAGS_HAVE_GC, __pyx_type___pyx_MemviewEnum_slots, }; #else static PyTypeObject __pyx_type___pyx_MemviewEnum = { PyVarObject_HEAD_INIT(0, 0) "astroscrappy.astroscrappy.""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*/ #if !CYTHON_USE_TYPE_SPECS 0, /*tp_dictoffset*/ #endif __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 #if CYTHON_USE_TP_FINALIZE 0, /*tp_finalize*/ #else NULL, /*tp_finalize*/ #endif #endif #if PY_VERSION_HEX >= 0x030800b1 && (!CYTHON_COMPILING_IN_PYPY || PYPY_VERSION_NUM >= 0x07030800) 0, /*tp_vectorcall*/ #endif #if __PYX_NEED_TP_PRINT_SLOT == 1 0, /*tp_print*/ #endif #if PY_VERSION_HEX >= 0x030C0000 0, /*tp_watched*/ #endif #if CYTHON_COMPILING_IN_PYPY && PY_VERSION_HEX >= 0x03090000 && PY_VERSION_HEX < 0x030a0000 0, /*tp_pypy_flags*/ #endif }; #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 CYTHON_COMPILING_IN_LIMITED_API allocfunc alloc_func = (allocfunc)PyType_GetSlot(t, Py_tp_alloc); o = alloc_func(t, 0); #else if (likely(!__Pyx_PyType_HasFeature(t, Py_TPFLAGS_IS_ABSTRACT))) { o = (*t->tp_alloc)(t, 0); } else { o = (PyObject *) PyBaseObject_Type.tp_new(t, __pyx_empty_tuple, 0); } if (unlikely(!o)) return 0; #endif 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((PY_VERSION_HEX >= 0x03080000 || __Pyx_PyType_HasFeature(Py_TYPE(o), Py_TPFLAGS_HAVE_FINALIZE)) && __Pyx_PyObject_GetSlot(o, tp_finalize, destructor)) && !__Pyx_PyObject_GC_IsFinalized(o)) { if (__Pyx_PyObject_GetSlot(o, tp_dealloc, destructor) == __pyx_tp_dealloc_memoryview) { 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); #if CYTHON_USE_TYPE_SLOTS || CYTHON_COMPILING_IN_PYPY (*Py_TYPE(o)->tp_free)(o); #else { freefunc tp_free = (freefunc)PyType_GetSlot(Py_TYPE(o), Py_tp_free); if (tp_free) tp_free(o); } #endif } 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 { __Pyx_TypeName o_type_name; o_type_name = __Pyx_PyType_GetName(Py_TYPE(o)); PyErr_Format(PyExc_NotImplementedError, "Subscript deletion not supported by " __Pyx_FMT_TYPENAME, o_type_name); __Pyx_DECREF_TypeName(o_type_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 PyObject *__pyx_specialmethod___pyx_memoryview___repr__(PyObject *self, CYTHON_UNUSED PyObject *arg) { return __pyx_memoryview___repr__(self); } static PyMethodDef __pyx_methods_memoryview[] = { {"__repr__", (PyCFunction)__pyx_specialmethod___pyx_memoryview___repr__, METH_NOARGS|METH_COEXIST, 0}, {"is_c_contig", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_memoryview_is_c_contig, __Pyx_METH_FASTCALL|METH_KEYWORDS, 0}, {"is_f_contig", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_memoryview_is_f_contig, __Pyx_METH_FASTCALL|METH_KEYWORDS, 0}, {"copy", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_memoryview_copy, __Pyx_METH_FASTCALL|METH_KEYWORDS, 0}, {"copy_fortran", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_memoryview_copy_fortran, __Pyx_METH_FASTCALL|METH_KEYWORDS, 0}, {"__reduce_cython__", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw___pyx_memoryview_1__reduce_cython__, __Pyx_METH_FASTCALL|METH_KEYWORDS, 0}, {"__setstate_cython__", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw___pyx_memoryview_3__setstate_cython__, __Pyx_METH_FASTCALL|METH_KEYWORDS, 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} }; #if CYTHON_USE_TYPE_SPECS #if !CYTHON_COMPILING_IN_LIMITED_API 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*/ }; #endif static PyType_Slot __pyx_type___pyx_memoryview_slots[] = { {Py_tp_dealloc, (void *)__pyx_tp_dealloc_memoryview}, {Py_tp_repr, (void *)__pyx_memoryview___repr__}, {Py_sq_length, (void *)__pyx_memoryview___len__}, {Py_sq_item, (void *)__pyx_sq_item_memoryview}, {Py_mp_length, (void *)__pyx_memoryview___len__}, {Py_mp_subscript, (void *)__pyx_memoryview___getitem__}, {Py_mp_ass_subscript, (void *)__pyx_mp_ass_subscript_memoryview}, {Py_tp_str, (void *)__pyx_memoryview___str__}, #if defined(Py_bf_getbuffer) {Py_bf_getbuffer, (void *)__pyx_memoryview_getbuffer}, #endif {Py_tp_traverse, (void *)__pyx_tp_traverse_memoryview}, {Py_tp_clear, (void *)__pyx_tp_clear_memoryview}, {Py_tp_methods, (void *)__pyx_methods_memoryview}, {Py_tp_getset, (void *)__pyx_getsets_memoryview}, {Py_tp_new, (void *)__pyx_tp_new_memoryview}, {0, 0}, }; static PyType_Spec __pyx_type___pyx_memoryview_spec = { "astroscrappy.astroscrappy.memoryview", sizeof(struct __pyx_memoryview_obj), 0, Py_TPFLAGS_DEFAULT|Py_TPFLAGS_HAVE_VERSION_TAG|Py_TPFLAGS_CHECKTYPES|Py_TPFLAGS_HAVE_NEWBUFFER|Py_TPFLAGS_BASETYPE|Py_TPFLAGS_HAVE_GC, __pyx_type___pyx_memoryview_slots, }; #else 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) "astroscrappy.astroscrappy.""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*/ #if !CYTHON_USE_TYPE_SPECS 0, /*tp_dictoffset*/ #endif 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 #if CYTHON_USE_TP_FINALIZE 0, /*tp_finalize*/ #else NULL, /*tp_finalize*/ #endif #endif #if PY_VERSION_HEX >= 0x030800b1 && (!CYTHON_COMPILING_IN_PYPY || PYPY_VERSION_NUM >= 0x07030800) 0, /*tp_vectorcall*/ #endif #if __PYX_NEED_TP_PRINT_SLOT == 1 0, /*tp_print*/ #endif #if PY_VERSION_HEX >= 0x030C0000 0, /*tp_watched*/ #endif #if CYTHON_COMPILING_IN_PYPY && PY_VERSION_HEX >= 0x03090000 && PY_VERSION_HEX < 0x030a0000 0, /*tp_pypy_flags*/ #endif }; #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((PY_VERSION_HEX >= 0x03080000 || __Pyx_PyType_HasFeature(Py_TYPE(o), Py_TPFLAGS_HAVE_FINALIZE)) && __Pyx_PyObject_GetSlot(o, tp_finalize, destructor)) && !__Pyx_PyObject_GC_IsFinalized(o)) { if (__Pyx_PyObject_GetSlot(o, tp_dealloc, destructor) == __pyx_tp_dealloc__memoryviewslice) { 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_XCLEAR_MEMVIEW(&p->from_slice, 1); return 0; } static PyMethodDef __pyx_methods__memoryviewslice[] = { {"__reduce_cython__", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw___pyx_memoryviewslice_1__reduce_cython__, __Pyx_METH_FASTCALL|METH_KEYWORDS, 0}, {"__setstate_cython__", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw___pyx_memoryviewslice_3__setstate_cython__, __Pyx_METH_FASTCALL|METH_KEYWORDS, 0}, {0, 0, 0, 0} }; #if CYTHON_USE_TYPE_SPECS static PyType_Slot __pyx_type___pyx_memoryviewslice_slots[] = { {Py_tp_dealloc, (void *)__pyx_tp_dealloc__memoryviewslice}, {Py_tp_doc, (void *)PyDoc_STR("Internal class for passing memoryview slices to Python")}, {Py_tp_traverse, (void *)__pyx_tp_traverse__memoryviewslice}, {Py_tp_clear, (void *)__pyx_tp_clear__memoryviewslice}, {Py_tp_methods, (void *)__pyx_methods__memoryviewslice}, {Py_tp_new, (void *)__pyx_tp_new__memoryviewslice}, {0, 0}, }; static PyType_Spec __pyx_type___pyx_memoryviewslice_spec = { "astroscrappy.astroscrappy._memoryviewslice", sizeof(struct __pyx_memoryviewslice_obj), 0, Py_TPFLAGS_DEFAULT|Py_TPFLAGS_HAVE_VERSION_TAG|Py_TPFLAGS_CHECKTYPES|Py_TPFLAGS_HAVE_NEWBUFFER|Py_TPFLAGS_BASETYPE|Py_TPFLAGS_HAVE_GC|Py_TPFLAGS_SEQUENCE, __pyx_type___pyx_memoryviewslice_slots, }; #else static PyTypeObject __pyx_type___pyx_memoryviewslice = { PyVarObject_HEAD_INIT(0, 0) "astroscrappy.astroscrappy.""_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 || 0 __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 || 0 __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|Py_TPFLAGS_SEQUENCE, /*tp_flags*/ PyDoc_STR("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*/ 0, /*tp_getset*/ 0, /*tp_base*/ 0, /*tp_dict*/ 0, /*tp_descr_get*/ 0, /*tp_descr_set*/ #if !CYTHON_USE_TYPE_SPECS 0, /*tp_dictoffset*/ #endif 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 #if CYTHON_USE_TP_FINALIZE 0, /*tp_finalize*/ #else NULL, /*tp_finalize*/ #endif #endif #if PY_VERSION_HEX >= 0x030800b1 && (!CYTHON_COMPILING_IN_PYPY || PYPY_VERSION_NUM >= 0x07030800) 0, /*tp_vectorcall*/ #endif #if __PYX_NEED_TP_PRINT_SLOT == 1 0, /*tp_print*/ #endif #if PY_VERSION_HEX >= 0x030C0000 0, /*tp_watched*/ #endif #if CYTHON_COMPILING_IN_PYPY && PY_VERSION_HEX >= 0x03090000 && PY_VERSION_HEX < 0x030a0000 0, /*tp_pypy_flags*/ #endif }; #endif static PyMethodDef __pyx_methods[] = { {0, 0, 0, 0} }; static int __pyx_import_star_set(PyObject *o, PyObject* py_name, char *name) { static const char* internal_type_names[] = { "Enum", "PyObject", "PyThread_type_lock", "Py_intptr_t", "__Pyx_TypeInfo", "__Pyx_memviewslice", "__pyx_atomic_int_type", "__pyx_buffer", "__pyx_ctuple_8c2c42__12astroscrappy_12astroscrappy__dunder_pyx_ctup__etc", "__pyx_ctuple_8c2c42__12astroscrappy_12astroscrappy__dunder_pyx_ctup__etc_struct", "__pyx_ctuple_Py_ssize_t", "__pyx_ctuple_Py_ssize_t_struct", "__pyx_ctuple_char__ptr", "__pyx_ctuple_char__ptr_struct", "__pyx_ctuple_double__and_double", "__pyx_ctuple_double__and_double_struct", "__pyx_ctuple_float__and_int", "__pyx_ctuple_float__and_int_struct", "__pyx_ctuple_int", "__pyx_ctuple_int__and_int", "__pyx_ctuple_int__and_int_struct", "__pyx_ctuple_int__and_long", "__pyx_ctuple_int__and_long_struct", "__pyx_ctuple_int_struct", "__pyx_ctuple_long", "__pyx_ctuple_long__and_long", "__pyx_ctuple_long__and_long__and_long", "__pyx_ctuple_long__and_long__and_long_struct", "__pyx_ctuple_long__and_long_struct", "__pyx_ctuple_long_struct", "__pyx_memoryview", "_memoryviewslice", "array", "bool", "memoryview", "uint8_t", 0 }; const char** type_name = internal_type_names; while (*type_name) { if (__Pyx_StrEq(name, *type_name)) { PyErr_Format(PyExc_TypeError, "Cannot overwrite C type %s", name); goto bad; } type_name++; } if (0); else if (__Pyx_StrEq(name, "PyExc_IndexError")) { PyErr_Format(PyExc_TypeError, "Cannot convert Python object PyExc_IndexError to PyObject *"); __PYX_ERR(1, 16, __pyx_L2_error) } else if (__Pyx_StrEq(name, "PyExc_ValueError")) { PyErr_Format(PyExc_TypeError, "Cannot convert Python object PyExc_ValueError to PyObject *"); __PYX_ERR(1, 17, __pyx_L2_error) } else if (__Pyx_StrEq(name, "Py_None")) { PyErr_Format(PyExc_TypeError, "Cannot convert Python object Py_None to PyObject *"); __PYX_ERR(1, 61, __pyx_L2_error) } else if (__Pyx_StrEq(name, "__pyx_collections_abc_Sequence")) { Py_INCREF(o); Py_DECREF(__pyx_collections_abc_Sequence); __pyx_collections_abc_Sequence = o; } else if (__Pyx_StrEq(name, "__pyx_memoryview_thread_locks")) { PyErr_Format(PyExc_TypeError, "Cannot convert Python object __pyx_memoryview_thread_locks to PyThread_type_lock [8]"); __PYX_ERR(1, 324, __pyx_L2_error) } else if (__Pyx_StrEq(name, "__pyx_memoryview_thread_locks_used")) { __pyx_memoryview_thread_locks_used = __Pyx_PyInt_As_int(o); if (unlikely((__pyx_memoryview_thread_locks_used == (int)-1) && PyErr_Occurred())) __PYX_ERR(1, 323, __pyx_L2_error) } else if (__Pyx_StrEq(name, "contiguous")) { Py_INCREF(o); Py_DECREF(contiguous); contiguous = o; } else if (__Pyx_StrEq(name, "generic")) { Py_INCREF(o); Py_DECREF(generic); generic = o; } else if (__Pyx_StrEq(name, "indirect")) { Py_INCREF(o); Py_DECREF(indirect); indirect = o; } else if (__Pyx_StrEq(name, "indirect_contiguous")) { Py_INCREF(o); Py_DECREF(indirect_contiguous); indirect_contiguous = o; } else if (__Pyx_StrEq(name, "strided")) { Py_INCREF(o); Py_DECREF(strided); strided = o; } else { if (PyObject_SetAttr(__pyx_m, py_name, o) < 0) goto bad; } return 0; __pyx_L2_error:; __Pyx_AddTraceback("astroscrappy.astroscrappy", __pyx_clineno, __pyx_lineno, __pyx_filename); bad: return -1; } static int __Pyx_import_all_from(PyObject *locals, PyObject *v) { PyObject *all = PyObject_GetAttrString(v, "__all__"); PyObject *dict, *name, *value; int skip_leading_underscores = 0; int pos, err; if (all == NULL) { if (!PyErr_ExceptionMatches(PyExc_AttributeError)) return -1; PyErr_Clear(); dict = PyObject_GetAttrString(v, "__dict__"); if (dict == NULL) { if (!PyErr_ExceptionMatches(PyExc_AttributeError)) return -1; PyErr_SetString(PyExc_ImportError, "from-import-* object has no __dict__ and no __all__"); return -1; } #if PY_MAJOR_VERSION < 3 all = PyObject_CallMethod(dict, (char *)"keys", NULL); #else all = PyMapping_Keys(dict); #endif Py_DECREF(dict); if (all == NULL) return -1; skip_leading_underscores = 1; } for (pos = 0, err = 0; ; pos++) { name = PySequence_GetItem(all, pos); if (name == NULL) { if (!PyErr_ExceptionMatches(PyExc_IndexError)) err = -1; else PyErr_Clear(); break; } if (skip_leading_underscores && #if PY_MAJOR_VERSION < 3 likely(PyString_Check(name)) && PyString_AS_STRING(name)[0] == '_') #else likely(PyUnicode_Check(name)) && likely(__Pyx_PyUnicode_GET_LENGTH(name)) && __Pyx_PyUnicode_READ_CHAR(name, 0) == '_') #endif { Py_DECREF(name); continue; } value = PyObject_GetAttr(v, name); if (value == NULL) err = -1; else if (PyDict_CheckExact(locals)) err = PyDict_SetItem(locals, name, value); else err = PyObject_SetItem(locals, name, value); Py_DECREF(name); Py_XDECREF(value); if (err != 0) break; } Py_DECREF(all); return err; } static int __pyx_import_star(PyObject* m) { int i; int ret = -1; char* s; PyObject *locals = 0; PyObject *list = 0; #if PY_MAJOR_VERSION >= 3 PyObject *utf8_name = 0; #endif PyObject *name; PyObject *item; locals = PyDict_New(); if (!locals) goto bad; if (__Pyx_import_all_from(locals, m) < 0) goto bad; list = PyDict_Items(locals); if (!list) goto bad; for(i=0; i= 3 utf8_name = PyUnicode_AsUTF8String(name); if (!utf8_name) goto bad; s = PyBytes_AS_STRING(utf8_name); if (__pyx_import_star_set(item, name, s) < 0) goto bad; Py_DECREF(utf8_name); utf8_name = 0; #else s = PyString_AsString(name); if (!s) goto bad; if (__pyx_import_star_set(item, name, s) < 0) goto bad; #endif } ret = 0; bad: Py_XDECREF(locals); Py_XDECREF(list); #if PY_MAJOR_VERSION >= 3 Py_XDECREF(utf8_name); #endif return ret; } #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 /* #### Code section: pystring_table ### */ static int __Pyx_CreateStringTabAndInitStrings(void) { __Pyx_StringTabEntry __pyx_string_tab[] = { {&__pyx_kp_u_, __pyx_k_, sizeof(__pyx_k_), 0, 1, 0, 0}, {&__pyx_n_s_ASCII, __pyx_k_ASCII, sizeof(__pyx_k_ASCII), 0, 0, 1, 1}, {&__pyx_kp_s_All_dimensions_preceding_dimensi, __pyx_k_All_dimensions_preceding_dimensi, sizeof(__pyx_k_All_dimensions_preceding_dimensi), 0, 0, 1, 0}, {&__pyx_n_s_AssertionError, __pyx_k_AssertionError, sizeof(__pyx_k_AssertionError), 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_n_u_C, __pyx_k_C, sizeof(__pyx_k_C), 0, 1, 0, 1}, {&__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_u_Cannot_index_with_type, __pyx_k_Cannot_index_with_type, sizeof(__pyx_k_Cannot_index_with_type), 0, 1, 0, 0}, {&__pyx_kp_s_Cannot_transpose_memoryview_with, __pyx_k_Cannot_transpose_memoryview_with, sizeof(__pyx_k_Cannot_transpose_memoryview_with), 0, 0, 1, 0}, {&__pyx_kp_s_Dimension_d_is_not_direct, __pyx_k_Dimension_d_is_not_direct, sizeof(__pyx_k_Dimension_d_is_not_direct), 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_n_s_ImportError, __pyx_k_ImportError, sizeof(__pyx_k_ImportError), 0, 0, 1, 1}, {&__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_Index_out_of_bounds_axis_d, __pyx_k_Index_out_of_bounds_axis_d, sizeof(__pyx_k_Index_out_of_bounds_axis_d), 0, 0, 1, 0}, {&__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_u_Invalid_mode_expected_c_or_fortr, __pyx_k_Invalid_mode_expected_c_or_fortr, sizeof(__pyx_k_Invalid_mode_expected_c_or_fortr), 0, 1, 0, 0}, {&__pyx_kp_u_Invalid_shape_in_axis, __pyx_k_Invalid_shape_in_axis, sizeof(__pyx_k_Invalid_shape_in_axis), 0, 1, 0, 0}, {&__pyx_kp_u_Iteration, __pyx_k_Iteration, sizeof(__pyx_k_Iteration), 0, 1, 0, 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_n_b_O, __pyx_k_O, sizeof(__pyx_k_O), 0, 0, 0, 1}, {&__pyx_kp_u_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, 1, 0, 0}, {&__pyx_n_s_PickleError, __pyx_k_PickleError, sizeof(__pyx_k_PickleError), 0, 0, 1, 1}, {&__pyx_kp_u_Please_choose_a_supported_PSF_mo, __pyx_k_Please_choose_a_supported_PSF_mo, sizeof(__pyx_k_Please_choose_a_supported_PSF_mo), 0, 1, 0, 0}, {&__pyx_kp_u_Please_choose_a_valid_fine_struc, __pyx_k_Please_choose_a_valid_fine_struc, sizeof(__pyx_k_Please_choose_a_valid_fine_struc), 0, 1, 0, 0}, {&__pyx_n_s_Sequence, __pyx_k_Sequence, sizeof(__pyx_k_Sequence), 0, 0, 1, 1}, {&__pyx_kp_u_Starting_L_A_Cosmic_iterations, __pyx_k_Starting_L_A_Cosmic_iterations, sizeof(__pyx_k_Starting_L_A_Cosmic_iterations), 0, 1, 0, 0}, {&__pyx_kp_s_Step_may_not_be_zero_axis_d, __pyx_k_Step_may_not_be_zero_axis_d, sizeof(__pyx_k_Step_may_not_be_zero_axis_d), 0, 0, 1, 0}, {&__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_u__2, __pyx_k__2, sizeof(__pyx_k__2), 0, 1, 0, 0}, {&__pyx_n_s__3, __pyx_k__3, sizeof(__pyx_k__3), 0, 0, 1, 1}, {&__pyx_n_s__38, __pyx_k__38, sizeof(__pyx_k__38), 0, 0, 1, 1}, {&__pyx_kp_u__6, __pyx_k__6, sizeof(__pyx_k__6), 0, 1, 0, 0}, {&__pyx_kp_u__7, __pyx_k__7, sizeof(__pyx_k__7), 0, 1, 0, 0}, {&__pyx_n_s_abc, __pyx_k_abc, sizeof(__pyx_k_abc), 0, 0, 1, 1}, {&__pyx_n_s_allocate_buffer, __pyx_k_allocate_buffer, sizeof(__pyx_k_allocate_buffer), 0, 0, 1, 1}, {&__pyx_kp_u_and, __pyx_k_and, sizeof(__pyx_k_and), 0, 1, 0, 0}, {&__pyx_n_s_arange, __pyx_k_arange, sizeof(__pyx_k_arange), 0, 0, 1, 1}, {&__pyx_n_s_array, __pyx_k_array, sizeof(__pyx_k_array), 0, 0, 1, 1}, {&__pyx_n_s_asarray, __pyx_k_asarray, sizeof(__pyx_k_asarray), 0, 0, 1, 1}, {&__pyx_n_s_astroscrappy_astroscrappy, __pyx_k_astroscrappy_astroscrappy, sizeof(__pyx_k_astroscrappy_astroscrappy), 0, 0, 1, 1}, {&__pyx_kp_s_astroscrappy_astroscrappy_pyx, __pyx_k_astroscrappy_astroscrappy_pyx, sizeof(__pyx_k_astroscrappy_astroscrappy_pyx), 0, 0, 1, 0}, {&__pyx_n_s_astype, __pyx_k_astype, sizeof(__pyx_k_astype), 0, 0, 1, 1}, {&__pyx_n_s_asyncio_coroutines, __pyx_k_asyncio_coroutines, sizeof(__pyx_k_asyncio_coroutines), 0, 0, 1, 1}, {&__pyx_n_s_background_level, __pyx_k_background_level, sizeof(__pyx_k_background_level), 0, 0, 1, 1}, {&__pyx_n_s_background_var_level, __pyx_k_background_var_level, sizeof(__pyx_k_background_var_level), 0, 0, 1, 1}, {&__pyx_n_s_base, __pyx_k_base, sizeof(__pyx_k_base), 0, 0, 1, 1}, {&__pyx_n_s_bkg, __pyx_k_bkg, sizeof(__pyx_k_bkg), 0, 0, 1, 1}, {&__pyx_n_s_bool, __pyx_k_bool, sizeof(__pyx_k_bool), 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_class_getitem, __pyx_k_class_getitem, sizeof(__pyx_k_class_getitem), 0, 0, 1, 1}, {&__pyx_n_s_clean_var, __pyx_k_clean_var, sizeof(__pyx_k_clean_var), 0, 0, 1, 1}, {&__pyx_n_s_cleanarr, __pyx_k_cleanarr, sizeof(__pyx_k_cleanarr), 0, 0, 1, 1}, {&__pyx_n_s_cleantype, __pyx_k_cleantype, sizeof(__pyx_k_cleantype), 0, 0, 1, 1}, {&__pyx_kp_u_cleantype_must_be_one_of_the_fol, __pyx_k_cleantype_must_be_one_of_the_fol, sizeof(__pyx_k_cleantype_must_be_one_of_the_fol), 0, 1, 0, 0}, {&__pyx_n_s_cline_in_traceback, __pyx_k_cline_in_traceback, sizeof(__pyx_k_cline_in_traceback), 0, 0, 1, 1}, {&__pyx_n_s_collections, __pyx_k_collections, sizeof(__pyx_k_collections), 0, 0, 1, 1}, {&__pyx_kp_s_collections_abc, __pyx_k_collections_abc, sizeof(__pyx_k_collections_abc), 0, 0, 1, 0}, {&__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_conved, __pyx_k_conved, sizeof(__pyx_k_conved), 0, 0, 1, 1}, {&__pyx_n_s_convolve, __pyx_k_convolve, sizeof(__pyx_k_convolve), 0, 0, 1, 1}, {&__pyx_n_u_convolve, __pyx_k_convolve, sizeof(__pyx_k_convolve), 0, 1, 0, 1}, {&__pyx_n_s_copy, __pyx_k_copy, sizeof(__pyx_k_copy), 0, 0, 1, 1}, {&__pyx_kp_u_cosmic_pixels_this_iteration, __pyx_k_cosmic_pixels_this_iteration, sizeof(__pyx_k_cosmic_pixels_this_iteration), 0, 1, 0, 0}, {&__pyx_n_s_cosmics, __pyx_k_cosmics, sizeof(__pyx_k_cosmics), 0, 0, 1, 1}, {&__pyx_n_s_count, __pyx_k_count, sizeof(__pyx_k_count), 0, 0, 1, 1}, {&__pyx_n_s_crmask, __pyx_k_crmask, sizeof(__pyx_k_crmask), 0, 0, 1, 1}, {&__pyx_n_s_data, __pyx_k_data, sizeof(__pyx_k_data), 0, 0, 1, 1}, {&__pyx_n_s_detect_cosmics, __pyx_k_detect_cosmics, sizeof(__pyx_k_detect_cosmics), 0, 0, 1, 1}, {&__pyx_n_s_dict, __pyx_k_dict, sizeof(__pyx_k_dict), 0, 0, 1, 1}, {&__pyx_n_s_dilate3, __pyx_k_dilate3, sizeof(__pyx_k_dilate3), 0, 0, 1, 1}, {&__pyx_n_s_dilate5, __pyx_k_dilate5, sizeof(__pyx_k_dilate5), 0, 0, 1, 1}, {&__pyx_n_s_dilsatpixels, __pyx_k_dilsatpixels, sizeof(__pyx_k_dilsatpixels), 0, 0, 1, 1}, {&__pyx_kp_u_disable, __pyx_k_disable, sizeof(__pyx_k_disable), 0, 1, 0, 0}, {&__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_empty, __pyx_k_empty, sizeof(__pyx_k_empty), 0, 0, 1, 1}, {&__pyx_n_s_empty_like, __pyx_k_empty_like, sizeof(__pyx_k_empty_like), 0, 0, 1, 1}, {&__pyx_kp_u_enable, __pyx_k_enable, sizeof(__pyx_k_enable), 0, 1, 0, 0}, {&__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_exp, __pyx_k_exp, sizeof(__pyx_k_exp), 0, 0, 1, 1}, {&__pyx_n_s_f, __pyx_k_f, sizeof(__pyx_k_f), 0, 0, 1, 1}, {&__pyx_n_s_flags, __pyx_k_flags, sizeof(__pyx_k_flags), 0, 0, 1, 1}, {&__pyx_n_s_float32, __pyx_k_float32, sizeof(__pyx_k_float32), 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_fsmode, __pyx_k_fsmode, sizeof(__pyx_k_fsmode), 0, 0, 1, 1}, {&__pyx_n_s_gain, __pyx_k_gain, sizeof(__pyx_k_gain), 0, 0, 1, 1}, {&__pyx_n_u_gauss, __pyx_k_gauss, sizeof(__pyx_k_gauss), 0, 1, 0, 1}, {&__pyx_n_s_gausskernel, __pyx_k_gausskernel, sizeof(__pyx_k_gausskernel), 0, 0, 1, 1}, {&__pyx_n_u_gaussx, __pyx_k_gaussx, sizeof(__pyx_k_gaussx), 0, 1, 0, 1}, {&__pyx_n_s_gaussxkernel, __pyx_k_gaussxkernel, sizeof(__pyx_k_gaussxkernel), 0, 0, 1, 1}, {&__pyx_n_u_gaussy, __pyx_k_gaussy, sizeof(__pyx_k_gaussy), 0, 1, 0, 1}, {&__pyx_n_s_gaussykernel, __pyx_k_gaussykernel, sizeof(__pyx_k_gaussykernel), 0, 0, 1, 1}, {&__pyx_kp_u_gc, __pyx_k_gc, sizeof(__pyx_k_gc), 0, 1, 0, 0}, {&__pyx_n_s_getstate, __pyx_k_getstate, sizeof(__pyx_k_getstate), 0, 0, 1, 1}, {&__pyx_n_s_gooddata, __pyx_k_gooddata, sizeof(__pyx_k_gooddata), 0, 0, 1, 1}, {&__pyx_n_s_goodpix, __pyx_k_goodpix, sizeof(__pyx_k_goodpix), 0, 0, 1, 1}, {&__pyx_n_s_goodvar, __pyx_k_goodvar, sizeof(__pyx_k_goodvar), 0, 0, 1, 1}, {&__pyx_kp_u_got, __pyx_k_got, sizeof(__pyx_k_got), 0, 1, 0, 0}, {&__pyx_kp_u_got_differing_extents_in_dimensi, __pyx_k_got_differing_extents_in_dimensi, sizeof(__pyx_k_got_differing_extents_in_dimensi), 0, 1, 0, 0}, {&__pyx_n_s_grow_mask, __pyx_k_grow_mask, sizeof(__pyx_k_grow_mask), 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_u_idw, __pyx_k_idw, sizeof(__pyx_k_idw), 0, 1, 0, 1}, {&__pyx_n_s_igoodpix, __pyx_k_igoodpix, sizeof(__pyx_k_igoodpix), 0, 0, 1, 1}, {&__pyx_n_s_import, __pyx_k_import, sizeof(__pyx_k_import), 0, 0, 1, 1}, {&__pyx_n_s_inbkg, __pyx_k_inbkg, sizeof(__pyx_k_inbkg), 0, 0, 1, 1}, {&__pyx_n_s_indat, __pyx_k_indat, sizeof(__pyx_k_indat), 0, 0, 1, 1}, {&__pyx_n_s_index, __pyx_k_index, sizeof(__pyx_k_index), 0, 0, 1, 1}, {&__pyx_n_s_initializing, __pyx_k_initializing, sizeof(__pyx_k_initializing), 0, 0, 1, 1}, {&__pyx_n_s_inmask, __pyx_k_inmask, sizeof(__pyx_k_inmask), 0, 0, 1, 1}, {&__pyx_n_s_invar, __pyx_k_invar, sizeof(__pyx_k_invar), 0, 0, 1, 1}, {&__pyx_n_s_is_coroutine, __pyx_k_is_coroutine, sizeof(__pyx_k_is_coroutine), 0, 0, 1, 1}, {&__pyx_kp_u_isenabled, __pyx_k_isenabled, sizeof(__pyx_k_isenabled), 0, 1, 0, 0}, {&__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_j, __pyx_k_j, sizeof(__pyx_k_j), 0, 0, 1, 1}, {&__pyx_n_s_kernel, __pyx_k_kernel, sizeof(__pyx_k_kernel), 0, 0, 1, 1}, {&__pyx_n_s_kernsize, __pyx_k_kernsize, sizeof(__pyx_k_kernsize), 0, 0, 1, 1}, {&__pyx_n_s_laplaceconvolve, __pyx_k_laplaceconvolve, sizeof(__pyx_k_laplaceconvolve), 0, 0, 1, 1}, {&__pyx_n_s_logical_and, __pyx_k_logical_and, sizeof(__pyx_k_logical_and), 0, 0, 1, 1}, {&__pyx_n_s_logical_not, __pyx_k_logical_not, sizeof(__pyx_k_logical_not), 0, 0, 1, 1}, {&__pyx_n_s_logical_or, __pyx_k_logical_or, sizeof(__pyx_k_logical_or), 0, 0, 1, 1}, {&__pyx_n_s_m5, __pyx_k_m5, sizeof(__pyx_k_m5), 0, 0, 1, 1}, {&__pyx_n_s_m7, __pyx_k_m7, sizeof(__pyx_k_m7), 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_u_meanmask, __pyx_k_meanmask, sizeof(__pyx_k_meanmask), 0, 1, 0, 1}, {&__pyx_n_s_medfilt3, __pyx_k_medfilt3, sizeof(__pyx_k_medfilt3), 0, 0, 1, 1}, {&__pyx_n_s_medfilt5, __pyx_k_medfilt5, sizeof(__pyx_k_medfilt5), 0, 0, 1, 1}, {&__pyx_n_s_medfilt7, __pyx_k_medfilt7, sizeof(__pyx_k_medfilt7), 0, 0, 1, 1}, {&__pyx_n_s_median, __pyx_k_median, sizeof(__pyx_k_median), 0, 0, 1, 1}, {&__pyx_n_u_median, __pyx_k_median, sizeof(__pyx_k_median), 0, 1, 0, 1}, {&__pyx_n_u_medmask, __pyx_k_medmask, sizeof(__pyx_k_medmask), 0, 1, 0, 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_u_moffat, __pyx_k_moffat, sizeof(__pyx_k_moffat), 0, 1, 0, 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_n_s_niter, __pyx_k_niter, sizeof(__pyx_k_niter), 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_noise, __pyx_k_noise, sizeof(__pyx_k_noise), 0, 0, 1, 1}, {&__pyx_n_s_np, __pyx_k_np, sizeof(__pyx_k_np), 0, 0, 1, 1}, {&__pyx_n_s_numcr, __pyx_k_numcr, sizeof(__pyx_k_numcr), 0, 0, 1, 1}, {&__pyx_n_s_numpy, __pyx_k_numpy, sizeof(__pyx_k_numpy), 0, 0, 1, 1}, {&__pyx_kp_u_numpy__core_multiarray_failed_to, __pyx_k_numpy__core_multiarray_failed_to, sizeof(__pyx_k_numpy__core_multiarray_failed_to), 0, 1, 0, 0}, {&__pyx_kp_u_numpy__core_umath_failed_to_impo, __pyx_k_numpy__core_umath_failed_to_impo, sizeof(__pyx_k_numpy__core_umath_failed_to_impo), 0, 1, 0, 0}, {&__pyx_n_s_nx, __pyx_k_nx, sizeof(__pyx_k_nx), 0, 0, 1, 1}, {&__pyx_n_s_ny, __pyx_k_ny, sizeof(__pyx_k_ny), 0, 0, 1, 1}, {&__pyx_n_s_obj, __pyx_k_obj, sizeof(__pyx_k_obj), 0, 0, 1, 1}, {&__pyx_n_s_objlim, __pyx_k_objlim, sizeof(__pyx_k_objlim), 0, 0, 1, 1}, {&__pyx_n_s_order, __pyx_k_order, sizeof(__pyx_k_order), 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_power, __pyx_k_power, sizeof(__pyx_k_power), 0, 0, 1, 1}, {&__pyx_n_s_print, __pyx_k_print, sizeof(__pyx_k_print), 0, 0, 1, 1}, {&__pyx_n_s_psfbeta, __pyx_k_psfbeta, sizeof(__pyx_k_psfbeta), 0, 0, 1, 1}, {&__pyx_n_s_psffwhm, __pyx_k_psffwhm, sizeof(__pyx_k_psffwhm), 0, 0, 1, 1}, {&__pyx_n_s_psfk, __pyx_k_psfk, sizeof(__pyx_k_psfk), 0, 0, 1, 1}, {&__pyx_n_s_psfmodel, __pyx_k_psfmodel, sizeof(__pyx_k_psfmodel), 0, 0, 1, 1}, {&__pyx_n_s_psfsize, __pyx_k_psfsize, sizeof(__pyx_k_psfsize), 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_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_r2, __pyx_k_r2, sizeof(__pyx_k_r2), 0, 0, 1, 1}, {&__pyx_n_s_range, __pyx_k_range, sizeof(__pyx_k_range), 0, 0, 1, 1}, {&__pyx_n_s_readnoise, __pyx_k_readnoise, sizeof(__pyx_k_readnoise), 0, 0, 1, 1}, {&__pyx_n_s_rebin, __pyx_k_rebin, sizeof(__pyx_k_rebin), 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_register, __pyx_k_register, sizeof(__pyx_k_register), 0, 0, 1, 1}, {&__pyx_n_s_s, __pyx_k_s, sizeof(__pyx_k_s), 0, 0, 1, 1}, {&__pyx_n_s_satlevel, __pyx_k_satlevel, sizeof(__pyx_k_satlevel), 0, 0, 1, 1}, {&__pyx_n_s_satpixels, __pyx_k_satpixels, sizeof(__pyx_k_satpixels), 0, 0, 1, 1}, {&__pyx_n_s_sepmed, __pyx_k_sepmed, sizeof(__pyx_k_sepmed), 0, 0, 1, 1}, {&__pyx_n_s_sepmedfilt5, __pyx_k_sepmedfilt5, sizeof(__pyx_k_sepmedfilt5), 0, 0, 1, 1}, {&__pyx_n_s_sepmedfilt7, __pyx_k_sepmedfilt7, sizeof(__pyx_k_sepmedfilt7), 0, 0, 1, 1}, {&__pyx_n_s_sepmedfilt9, __pyx_k_sepmedfilt9, sizeof(__pyx_k_sepmedfilt9), 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_sigclip, __pyx_k_sigclip, sizeof(__pyx_k_sigclip), 0, 0, 1, 1}, {&__pyx_n_s_sigcliplow, __pyx_k_sigcliplow, sizeof(__pyx_k_sigcliplow), 0, 0, 1, 1}, {&__pyx_n_s_sigfrac, __pyx_k_sigfrac, sizeof(__pyx_k_sigfrac), 0, 0, 1, 1}, {&__pyx_n_s_sigma2, __pyx_k_sigma2, sizeof(__pyx_k_sigma2), 0, 0, 1, 1}, {&__pyx_n_s_size, __pyx_k_size, sizeof(__pyx_k_size), 0, 0, 1, 1}, {&__pyx_n_s_sp, __pyx_k_sp, sizeof(__pyx_k_sp), 0, 0, 1, 1}, {&__pyx_n_s_spec, __pyx_k_spec, sizeof(__pyx_k_spec), 0, 0, 1, 1}, {&__pyx_n_s_sqrt, __pyx_k_sqrt, sizeof(__pyx_k_sqrt), 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_struct, __pyx_k_struct, sizeof(__pyx_k_struct), 0, 0, 1, 1}, {&__pyx_n_s_subsam, __pyx_k_subsam, sizeof(__pyx_k_subsam), 0, 0, 1, 1}, {&__pyx_n_s_subsample, __pyx_k_subsample, sizeof(__pyx_k_subsample), 0, 0, 1, 1}, {&__pyx_n_s_sum, __pyx_k_sum, sizeof(__pyx_k_sum), 0, 0, 1, 1}, {&__pyx_n_s_sys, __pyx_k_sys, sizeof(__pyx_k_sys), 0, 0, 1, 1}, {&__pyx_n_s_test, __pyx_k_test, sizeof(__pyx_k_test), 0, 0, 1, 1}, {&__pyx_n_s_tile, __pyx_k_tile, sizeof(__pyx_k_tile), 0, 0, 1, 1}, {&__pyx_n_s_transpose, __pyx_k_transpose, sizeof(__pyx_k_transpose), 0, 0, 1, 1}, {&__pyx_n_s_uint8, __pyx_k_uint8, sizeof(__pyx_k_uint8), 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_update_mask, __pyx_k_update_mask, sizeof(__pyx_k_update_mask), 0, 0, 1, 1}, {&__pyx_n_s_utils, __pyx_k_utils, sizeof(__pyx_k_utils), 0, 0, 1, 1}, {&__pyx_n_s_verbose, __pyx_k_verbose, sizeof(__pyx_k_verbose), 0, 0, 1, 1}, {&__pyx_n_s_version_info, __pyx_k_version_info, sizeof(__pyx_k_version_info), 0, 0, 1, 1}, {&__pyx_n_s_x, __pyx_k_x, sizeof(__pyx_k_x), 0, 0, 1, 1}, {&__pyx_n_s_y, __pyx_k_y, sizeof(__pyx_k_y), 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} }; return __Pyx_InitStrings(__pyx_string_tab); } /* #### Code section: cached_builtins ### */ static CYTHON_SMALL_CODE int __Pyx_InitCachedBuiltins(void) { __pyx_builtin_ValueError = __Pyx_GetBuiltinName(__pyx_n_s_ValueError); if (!__pyx_builtin_ValueError) __PYX_ERR(0, 261, __pyx_L1_error) __pyx_builtin_print = __Pyx_GetBuiltinName(__pyx_n_s_print); if (!__pyx_builtin_print) __PYX_ERR(0, 275, __pyx_L1_error) __pyx_builtin_range = __Pyx_GetBuiltinName(__pyx_n_s_range); if (!__pyx_builtin_range) __PYX_ERR(0, 276, __pyx_L1_error) __pyx_builtin___import__ = __Pyx_GetBuiltinName(__pyx_n_s_import); if (!__pyx_builtin___import__) __PYX_ERR(1, 100, __pyx_L1_error) __pyx_builtin_MemoryError = __Pyx_GetBuiltinName(__pyx_n_s_MemoryError); if (!__pyx_builtin_MemoryError) __PYX_ERR(1, 156, __pyx_L1_error) __pyx_builtin_enumerate = __Pyx_GetBuiltinName(__pyx_n_s_enumerate); if (!__pyx_builtin_enumerate) __PYX_ERR(1, 159, __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_AssertionError = __Pyx_GetBuiltinName(__pyx_n_s_AssertionError); if (!__pyx_builtin_AssertionError) __PYX_ERR(1, 373, __pyx_L1_error) __pyx_builtin_Ellipsis = __Pyx_GetBuiltinName(__pyx_n_s_Ellipsis); if (!__pyx_builtin_Ellipsis) __PYX_ERR(1, 408, __pyx_L1_error) __pyx_builtin_id = __Pyx_GetBuiltinName(__pyx_n_s_id); if (!__pyx_builtin_id) __PYX_ERR(1, 618, __pyx_L1_error) __pyx_builtin_IndexError = __Pyx_GetBuiltinName(__pyx_n_s_IndexError); if (!__pyx_builtin_IndexError) __PYX_ERR(1, 914, __pyx_L1_error) __pyx_builtin_ImportError = __Pyx_GetBuiltinName(__pyx_n_s_ImportError); if (!__pyx_builtin_ImportError) __PYX_ERR(2, 1026, __pyx_L1_error) return 0; __pyx_L1_error:; return -1; } /* #### Code section: cached_constants ### */ static CYTHON_SMALL_CODE int __Pyx_InitCachedConstants(void) { __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__Pyx_InitCachedConstants", 0); /* "View.MemoryView":582 * 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__4 = PyTuple_New(1); if (unlikely(!__pyx_tuple__4)) __PYX_ERR(1, 582, __pyx_L1_error) __Pyx_GOTREF(__pyx_tuple__4); __Pyx_INCREF(__pyx_int_neg_1); __Pyx_GIVEREF(__pyx_int_neg_1); if (__Pyx_PyTuple_SET_ITEM(__pyx_tuple__4, 0, __pyx_int_neg_1)) __PYX_ERR(1, 582, __pyx_L1_error); __Pyx_GIVEREF(__pyx_tuple__4); /* "View.MemoryView":679 * tup = index if isinstance(index, tuple) else (index,) * * result = [slice(None)] * ndim # <<<<<<<<<<<<<< * have_slices = False * seen_ellipsis = False */ __pyx_slice__5 = PySlice_New(Py_None, Py_None, Py_None); if (unlikely(!__pyx_slice__5)) __PYX_ERR(1, 679, __pyx_L1_error) __Pyx_GOTREF(__pyx_slice__5); __Pyx_GIVEREF(__pyx_slice__5); /* "(tree fragment)":4 * cdef object __pyx_PickleError * cdef object __pyx_result * if __pyx_checksum not in (0x82a3537, 0x6ae9995, 0xb068931): # <<<<<<<<<<<<<< * from pickle import PickleError as __pyx_PickleError * raise __pyx_PickleError, "Incompatible checksums (0x%x vs (0x82a3537, 0x6ae9995, 0xb068931) = (name))" % __pyx_checksum */ __pyx_tuple__8 = PyTuple_Pack(3, __pyx_int_136983863, __pyx_int_112105877, __pyx_int_184977713); if (unlikely(!__pyx_tuple__8)) __PYX_ERR(1, 4, __pyx_L1_error) __Pyx_GOTREF(__pyx_tuple__8); __Pyx_GIVEREF(__pyx_tuple__8); /* "../../../../../tmp/build-env-2vlxkjf_/lib/python3.12/site-packages/numpy/__init__.cython-30.pxd":1026 * __pyx_import_array() * except Exception: * raise ImportError("numpy._core.multiarray failed to import") # <<<<<<<<<<<<<< * * cdef inline int import_umath() except -1: */ __pyx_tuple__9 = PyTuple_Pack(1, __pyx_kp_u_numpy__core_multiarray_failed_to); if (unlikely(!__pyx_tuple__9)) __PYX_ERR(2, 1026, __pyx_L1_error) __Pyx_GOTREF(__pyx_tuple__9); __Pyx_GIVEREF(__pyx_tuple__9); /* "../../../../../tmp/build-env-2vlxkjf_/lib/python3.12/site-packages/numpy/__init__.cython-30.pxd":1032 * _import_umath() * except Exception: * raise ImportError("numpy._core.umath failed to import") # <<<<<<<<<<<<<< * * cdef inline int import_ufunc() except -1: */ __pyx_tuple__10 = PyTuple_Pack(1, __pyx_kp_u_numpy__core_umath_failed_to_impo); if (unlikely(!__pyx_tuple__10)) __PYX_ERR(2, 1032, __pyx_L1_error) __Pyx_GOTREF(__pyx_tuple__10); __Pyx_GIVEREF(__pyx_tuple__10); /* "astroscrappy/astroscrappy.pyx":200 * # Set the initial values to those of the data array * # Multiply by the gain; the statistics only work properly with electrons. * cleanarr[:, :] = indat[:, :] * gain # <<<<<<<<<<<<<< * * if inbkg is not None: */ __pyx_tuple__11 = PyTuple_Pack(2, __pyx_slice__5, __pyx_slice__5); if (unlikely(!__pyx_tuple__11)) __PYX_ERR(0, 200, __pyx_L1_error) __Pyx_GOTREF(__pyx_tuple__11); __Pyx_GIVEREF(__pyx_tuple__11); /* "astroscrappy/astroscrappy.pyx":261 * psfk = moffatkernel(psffwhm, psfbeta, psfsize) * else: * raise ValueError('Please choose a supported PSF model.') # <<<<<<<<<<<<<< * # Reverse the psf kernel as that is what we use in the convolution throughout * psfk[:, :] = psfk[::-1, ::-1] */ __pyx_tuple__12 = PyTuple_Pack(1, __pyx_kp_u_Please_choose_a_supported_PSF_mo); if (unlikely(!__pyx_tuple__12)) __PYX_ERR(0, 261, __pyx_L1_error) __Pyx_GOTREF(__pyx_tuple__12); __Pyx_GIVEREF(__pyx_tuple__12); /* "astroscrappy/astroscrappy.pyx":263 * raise ValueError('Please choose a supported PSF model.') * # Reverse the psf kernel as that is what we use in the convolution throughout * psfk[:, :] = psfk[::-1, ::-1] # <<<<<<<<<<<<<< * * # Define a cosmic ray mask */ __pyx_slice__13 = PySlice_New(Py_None, Py_None, __pyx_int_neg_1); if (unlikely(!__pyx_slice__13)) __PYX_ERR(0, 263, __pyx_L1_error) __Pyx_GOTREF(__pyx_slice__13); __Pyx_GIVEREF(__pyx_slice__13); __pyx_tuple__14 = PyTuple_Pack(2, __pyx_slice__13, __pyx_slice__13); if (unlikely(!__pyx_tuple__14)) __PYX_ERR(0, 263, __pyx_L1_error) __Pyx_GOTREF(__pyx_tuple__14); __Pyx_GIVEREF(__pyx_tuple__14); /* "astroscrappy/astroscrappy.pyx":345 * f = medfilt3(cleanarr) * else: * raise ValueError('Please choose a valid fine structure mode.') # <<<<<<<<<<<<<< * * if sepmed: */ __pyx_tuple__15 = PyTuple_Pack(1, __pyx_kp_u_Please_choose_a_valid_fine_struc); if (unlikely(!__pyx_tuple__15)) __PYX_ERR(0, 345, __pyx_L1_error) __Pyx_GOTREF(__pyx_tuple__15); __Pyx_GIVEREF(__pyx_tuple__15); /* "astroscrappy/astroscrappy.pyx":419 * clean_idwinterp(clean_var, crmask, mask, nx, ny, background_var_level) * else: * raise ValueError("""cleantype must be one of the following values: # <<<<<<<<<<<<<< * [median, meanmask, medmask, idw]""") * */ __pyx_tuple__16 = PyTuple_Pack(1, __pyx_kp_u_cleantype_must_be_one_of_the_fol); if (unlikely(!__pyx_tuple__16)) __PYX_ERR(0, 419, __pyx_L1_error) __Pyx_GOTREF(__pyx_tuple__16); __Pyx_GIVEREF(__pyx_tuple__16); /* "View.MemoryView":100 * cdef object __pyx_collections_abc_Sequence "__pyx_collections_abc_Sequence" * try: * if __import__("sys").version_info >= (3, 3): # <<<<<<<<<<<<<< * __pyx_collections_abc_Sequence = __import__("collections.abc").abc.Sequence * else: */ __pyx_tuple__17 = PyTuple_Pack(1, __pyx_n_s_sys); if (unlikely(!__pyx_tuple__17)) __PYX_ERR(1, 100, __pyx_L1_error) __Pyx_GOTREF(__pyx_tuple__17); __Pyx_GIVEREF(__pyx_tuple__17); __pyx_tuple__18 = PyTuple_Pack(2, __pyx_int_3, __pyx_int_3); if (unlikely(!__pyx_tuple__18)) __PYX_ERR(1, 100, __pyx_L1_error) __Pyx_GOTREF(__pyx_tuple__18); __Pyx_GIVEREF(__pyx_tuple__18); /* "View.MemoryView":101 * try: * if __import__("sys").version_info >= (3, 3): * __pyx_collections_abc_Sequence = __import__("collections.abc").abc.Sequence # <<<<<<<<<<<<<< * else: * __pyx_collections_abc_Sequence = __import__("collections").Sequence */ __pyx_tuple__19 = PyTuple_Pack(1, __pyx_kp_s_collections_abc); if (unlikely(!__pyx_tuple__19)) __PYX_ERR(1, 101, __pyx_L1_error) __Pyx_GOTREF(__pyx_tuple__19); __Pyx_GIVEREF(__pyx_tuple__19); /* "View.MemoryView":103 * __pyx_collections_abc_Sequence = __import__("collections.abc").abc.Sequence * else: * __pyx_collections_abc_Sequence = __import__("collections").Sequence # <<<<<<<<<<<<<< * except: * */ __pyx_tuple__20 = PyTuple_Pack(1, __pyx_n_s_collections); if (unlikely(!__pyx_tuple__20)) __PYX_ERR(1, 103, __pyx_L1_error) __Pyx_GOTREF(__pyx_tuple__20); __Pyx_GIVEREF(__pyx_tuple__20); /* "View.MemoryView":309 * return self.name * * cdef generic = Enum("") # <<<<<<<<<<<<<< * cdef strided = Enum("") # default * cdef indirect = Enum("") */ __pyx_tuple__21 = PyTuple_Pack(1, __pyx_kp_s_strided_and_direct_or_indirect); if (unlikely(!__pyx_tuple__21)) __PYX_ERR(1, 309, __pyx_L1_error) __Pyx_GOTREF(__pyx_tuple__21); __Pyx_GIVEREF(__pyx_tuple__21); /* "View.MemoryView":310 * * cdef generic = Enum("") * cdef strided = Enum("") # default # <<<<<<<<<<<<<< * cdef indirect = Enum("") * */ __pyx_tuple__22 = PyTuple_Pack(1, __pyx_kp_s_strided_and_direct); if (unlikely(!__pyx_tuple__22)) __PYX_ERR(1, 310, __pyx_L1_error) __Pyx_GOTREF(__pyx_tuple__22); __Pyx_GIVEREF(__pyx_tuple__22); /* "View.MemoryView":311 * cdef generic = Enum("") * cdef strided = Enum("") # default * cdef indirect = Enum("") # <<<<<<<<<<<<<< * * */ __pyx_tuple__23 = PyTuple_Pack(1, __pyx_kp_s_strided_and_indirect); if (unlikely(!__pyx_tuple__23)) __PYX_ERR(1, 311, __pyx_L1_error) __Pyx_GOTREF(__pyx_tuple__23); __Pyx_GIVEREF(__pyx_tuple__23); /* "View.MemoryView":314 * * * cdef contiguous = Enum("") # <<<<<<<<<<<<<< * cdef indirect_contiguous = Enum("") * */ __pyx_tuple__24 = PyTuple_Pack(1, __pyx_kp_s_contiguous_and_direct); if (unlikely(!__pyx_tuple__24)) __PYX_ERR(1, 314, __pyx_L1_error) __Pyx_GOTREF(__pyx_tuple__24); __Pyx_GIVEREF(__pyx_tuple__24); /* "View.MemoryView":315 * * cdef contiguous = Enum("") * cdef indirect_contiguous = Enum("") # <<<<<<<<<<<<<< * * */ __pyx_tuple__25 = PyTuple_Pack(1, __pyx_kp_s_contiguous_and_indirect); if (unlikely(!__pyx_tuple__25)) __PYX_ERR(1, 315, __pyx_L1_error) __Pyx_GOTREF(__pyx_tuple__25); __Pyx_GIVEREF(__pyx_tuple__25); /* "(tree fragment)":1 * def __pyx_unpickle_Enum(__pyx_type, long __pyx_checksum, __pyx_state): # <<<<<<<<<<<<<< * cdef object __pyx_PickleError * cdef object __pyx_result */ __pyx_tuple__26 = 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__26)) __PYX_ERR(1, 1, __pyx_L1_error) __Pyx_GOTREF(__pyx_tuple__26); __Pyx_GIVEREF(__pyx_tuple__26); __pyx_codeobj__27 = (PyObject*)__Pyx_PyCode_New(3, 0, 0, 5, 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_stringsource, __pyx_n_s_pyx_unpickle_Enum, 1, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__27)) __PYX_ERR(1, 1, __pyx_L1_error) /* "astroscrappy/astroscrappy.pyx":26 * from libc.stdlib cimport malloc, free * * def detect_cosmics(indat, inmask=None, inbkg=None, invar=None, float sigclip=4.5, # <<<<<<<<<<<<<< * float sigfrac=0.3, float objlim=5.0, float gain=1.0, * float readnoise=6.5, float satlevel=65536.0, */ __pyx_tuple__28 = PyTuple_Pack(46, __pyx_n_s_indat, __pyx_n_s_inmask, __pyx_n_s_inbkg, __pyx_n_s_invar, __pyx_n_s_sigclip, __pyx_n_s_sigfrac, __pyx_n_s_objlim, __pyx_n_s_gain, __pyx_n_s_readnoise, __pyx_n_s_satlevel, __pyx_n_s_niter, __pyx_n_s_sepmed, __pyx_n_s_cleantype, __pyx_n_s_fsmode, __pyx_n_s_psfmodel, __pyx_n_s_psffwhm, __pyx_n_s_psfsize, __pyx_n_s_psfk, __pyx_n_s_psfbeta, __pyx_n_s_verbose, __pyx_n_s_nx, __pyx_n_s_ny, __pyx_n_s_i, __pyx_n_s_j, __pyx_n_s_cleanarr, __pyx_n_s_bkg, __pyx_n_s_mask, __pyx_n_s_clean_var, __pyx_n_s_gooddata, __pyx_n_s_igoodpix, __pyx_n_s_background_level, __pyx_n_s_goodvar, __pyx_n_s_background_var_level, __pyx_n_s_crmask, __pyx_n_s_sigcliplow, __pyx_n_s_subsam, __pyx_n_s_conved, __pyx_n_s_s, __pyx_n_s_m5, __pyx_n_s_noise, __pyx_n_s_sp, __pyx_n_s_goodpix, __pyx_n_s_cosmics, __pyx_n_s_f, __pyx_n_s_m7, __pyx_n_s_numcr); if (unlikely(!__pyx_tuple__28)) __PYX_ERR(0, 26, __pyx_L1_error) __Pyx_GOTREF(__pyx_tuple__28); __Pyx_GIVEREF(__pyx_tuple__28); __pyx_codeobj__29 = (PyObject*)__Pyx_PyCode_New(20, 0, 0, 46, 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_astroscrappy_astroscrappy_pyx, __pyx_n_s_detect_cosmics, 26, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__29)) __PYX_ERR(0, 26, __pyx_L1_error) /* "astroscrappy/astroscrappy.pyx":431 * * * def update_mask(np.ndarray[np.float32_t, ndim=2, mode='c', cast=True] data, # <<<<<<<<<<<<<< * np.ndarray[np.uint8_t, ndim=2, mode='c', cast=True] mask, * float satlevel, bool sepmed): */ __pyx_tuple__30 = PyTuple_Pack(8, __pyx_n_s_data, __pyx_n_s_mask, __pyx_n_s_satlevel, __pyx_n_s_sepmed, __pyx_n_s_satpixels, __pyx_n_s_m5, __pyx_n_s_grow_mask, __pyx_n_s_dilsatpixels); if (unlikely(!__pyx_tuple__30)) __PYX_ERR(0, 431, __pyx_L1_error) __Pyx_GOTREF(__pyx_tuple__30); __Pyx_GIVEREF(__pyx_tuple__30); __pyx_codeobj__31 = (PyObject*)__Pyx_PyCode_New(4, 0, 0, 8, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__30, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_astroscrappy_astroscrappy_pyx, __pyx_n_s_update_mask, 431, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__31)) __PYX_ERR(0, 431, __pyx_L1_error) /* "astroscrappy/astroscrappy.pyx":727 * * * def gausskernel(float psffwhm, int kernsize): # <<<<<<<<<<<<<< * """gausskernel(psffwhm, kernsize)\n * Calculate a circular Gaussian psf kernel. */ __pyx_tuple__32 = PyTuple_Pack(7, __pyx_n_s_psffwhm, __pyx_n_s_kernsize, __pyx_n_s_kernel, __pyx_n_s_x, __pyx_n_s_y, __pyx_n_s_r2, __pyx_n_s_sigma2); if (unlikely(!__pyx_tuple__32)) __PYX_ERR(0, 727, __pyx_L1_error) __Pyx_GOTREF(__pyx_tuple__32); __Pyx_GIVEREF(__pyx_tuple__32); __pyx_codeobj__33 = (PyObject*)__Pyx_PyCode_New(2, 0, 0, 7, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__32, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_astroscrappy_astroscrappy_pyx, __pyx_n_s_gausskernel, 727, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__33)) __PYX_ERR(0, 727, __pyx_L1_error) /* "astroscrappy/astroscrappy.pyx":759 * * * def gaussxkernel(float psffwhm, int kernsize): # <<<<<<<<<<<<<< * """gaussxkernel(psffwhm, kernsize)\n * Calculate a Gaussian kernel in the x-direction. */ __pyx_tuple__34 = PyTuple_Pack(5, __pyx_n_s_psffwhm, __pyx_n_s_kernsize, __pyx_n_s_kernel, __pyx_n_s_x, __pyx_n_s_sigma2); if (unlikely(!__pyx_tuple__34)) __PYX_ERR(0, 759, __pyx_L1_error) __Pyx_GOTREF(__pyx_tuple__34); __Pyx_GIVEREF(__pyx_tuple__34); __pyx_codeobj__35 = (PyObject*)__Pyx_PyCode_New(2, 0, 0, 5, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__34, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_astroscrappy_astroscrappy_pyx, __pyx_n_s_gaussxkernel, 759, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__35)) __PYX_ERR(0, 759, __pyx_L1_error) /* "astroscrappy/astroscrappy.pyx":790 * * * def gaussykernel(float psffwhm, int kernsize): # <<<<<<<<<<<<<< * """gaussykernel(psffwhm, kernsize)\n * Calculate a Gaussian kernel in the y-direction. */ __pyx_tuple__36 = PyTuple_Pack(6, __pyx_n_s_psffwhm, __pyx_n_s_kernsize, __pyx_n_s_kernel, __pyx_n_s_x, __pyx_n_s_y, __pyx_n_s_sigma2); if (unlikely(!__pyx_tuple__36)) __PYX_ERR(0, 790, __pyx_L1_error) __Pyx_GOTREF(__pyx_tuple__36); __Pyx_GIVEREF(__pyx_tuple__36); __pyx_codeobj__37 = (PyObject*)__Pyx_PyCode_New(2, 0, 0, 6, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__36, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_astroscrappy_astroscrappy_pyx, __pyx_n_s_gaussykernel, 790, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__37)) __PYX_ERR(0, 790, __pyx_L1_error) __Pyx_RefNannyFinishContext(); return 0; __pyx_L1_error:; __Pyx_RefNannyFinishContext(); return -1; } /* #### Code section: init_constants ### */ static CYTHON_SMALL_CODE int __Pyx_InitConstants(void) { if (__Pyx_CreateStringTabAndInitStrings() < 0) __PYX_ERR(0, 1, __pyx_L1_error); __pyx_float_0_ = PyFloat_FromDouble(0.); if (unlikely(!__pyx_float_0_)) __PYX_ERR(0, 1, __pyx_L1_error) __pyx_float_1_ = PyFloat_FromDouble(1.); if (unlikely(!__pyx_float_1_)) __PYX_ERR(0, 1, __pyx_L1_error) __pyx_float_0_0 = PyFloat_FromDouble(0.0); if (unlikely(!__pyx_float_0_0)) __PYX_ERR(0, 1, __pyx_L1_error) __pyx_float_0_5 = PyFloat_FromDouble(0.5); if (unlikely(!__pyx_float_0_5)) __PYX_ERR(0, 1, __pyx_L1_error) __pyx_float_1_0 = PyFloat_FromDouble(1.0); if (unlikely(!__pyx_float_1_0)) __PYX_ERR(0, 1, __pyx_L1_error) __pyx_float_2_0 = PyFloat_FromDouble(2.0); if (unlikely(!__pyx_float_2_0)) __PYX_ERR(0, 1, __pyx_L1_error) __pyx_float_0_01 = PyFloat_FromDouble(0.01); if (unlikely(!__pyx_float_0_01)) __PYX_ERR(0, 1, __pyx_L1_error) __pyx_float_0_00001 = PyFloat_FromDouble(0.00001); if (unlikely(!__pyx_float_0_00001)) __PYX_ERR(0, 1, __pyx_L1_error) __pyx_float_0_4472136 = PyFloat_FromDouble(0.4472136); if (unlikely(!__pyx_float_0_4472136)) __PYX_ERR(0, 1, __pyx_L1_error) __pyx_float_0_35355339 = PyFloat_FromDouble(0.35355339); if (unlikely(!__pyx_float_0_35355339)) __PYX_ERR(0, 1, __pyx_L1_error) __pyx_float_0_70710678 = PyFloat_FromDouble(0.70710678); if (unlikely(!__pyx_float_0_70710678)) __PYX_ERR(0, 1, __pyx_L1_error) __pyx_float_neg_0_5 = PyFloat_FromDouble(-0.5); if (unlikely(!__pyx_float_neg_0_5)) __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; } /* #### Code section: init_globals ### */ static CYTHON_SMALL_CODE int __Pyx_InitGlobals(void) { /* AssertionsEnabled.init */ if (likely(__Pyx_init_assertions_enabled() == 0)); else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 1, __pyx_L1_error) /* InitThreads.init */ #if defined(WITH_THREAD) && PY_VERSION_HEX < 0x030700F0 PyEval_InitThreads(); #endif if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 1, __pyx_L1_error) return 0; __pyx_L1_error:; return -1; } /* #### Code section: init_module ### */ 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_collections_abc_Sequence = Py_None; Py_INCREF(Py_None); 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 PyObject *__pyx_t_1 = NULL; 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 CYTHON_USE_TYPE_SPECS __pyx_array_type = (PyTypeObject *) __Pyx_PyType_FromModuleAndSpec(__pyx_m, &__pyx_type___pyx_array_spec, NULL); if (unlikely(!__pyx_array_type)) __PYX_ERR(1, 114, __pyx_L1_error) #if !CYTHON_COMPILING_IN_LIMITED_API __pyx_array_type->tp_as_buffer = &__pyx_tp_as_buffer_array; if (!__pyx_array_type->tp_as_buffer->bf_releasebuffer && __pyx_array_type->tp_base->tp_as_buffer && __pyx_array_type->tp_base->tp_as_buffer->bf_releasebuffer) { __pyx_array_type->tp_as_buffer->bf_releasebuffer = __pyx_array_type->tp_base->tp_as_buffer->bf_releasebuffer; } #elif defined(Py_bf_getbuffer) && defined(Py_bf_releasebuffer) /* PY_VERSION_HEX >= 0x03090000 || Py_LIMITED_API >= 0x030B0000 */ #elif defined(_MSC_VER) #pragma message ("The buffer protocol is not supported in the Limited C-API < 3.11.") #else #warning "The buffer protocol is not supported in the Limited C-API < 3.11." #endif if (__Pyx_fix_up_extension_type_from_spec(&__pyx_type___pyx_array_spec, __pyx_array_type) < 0) __PYX_ERR(1, 114, __pyx_L1_error) #else __pyx_array_type = &__pyx_type___pyx_array; #endif #if !CYTHON_COMPILING_IN_LIMITED_API #endif #if !CYTHON_USE_TYPE_SPECS if (__Pyx_PyType_Ready(__pyx_array_type) < 0) __PYX_ERR(1, 114, __pyx_L1_error) #endif #if PY_MAJOR_VERSION < 3 __pyx_array_type->tp_print = 0; #endif if (__Pyx_SetVtable(__pyx_array_type, __pyx_vtabptr_array) < 0) __PYX_ERR(1, 114, __pyx_L1_error) #if !CYTHON_COMPILING_IN_LIMITED_API if (__Pyx_MergeVtables(__pyx_array_type) < 0) __PYX_ERR(1, 114, __pyx_L1_error) #endif #if !CYTHON_COMPILING_IN_LIMITED_API if (__Pyx_setup_reduce((PyObject *) __pyx_array_type) < 0) __PYX_ERR(1, 114, __pyx_L1_error) #endif #if CYTHON_USE_TYPE_SPECS __pyx_MemviewEnum_type = (PyTypeObject *) __Pyx_PyType_FromModuleAndSpec(__pyx_m, &__pyx_type___pyx_MemviewEnum_spec, NULL); if (unlikely(!__pyx_MemviewEnum_type)) __PYX_ERR(1, 302, __pyx_L1_error) if (__Pyx_fix_up_extension_type_from_spec(&__pyx_type___pyx_MemviewEnum_spec, __pyx_MemviewEnum_type) < 0) __PYX_ERR(1, 302, __pyx_L1_error) #else __pyx_MemviewEnum_type = &__pyx_type___pyx_MemviewEnum; #endif #if !CYTHON_COMPILING_IN_LIMITED_API #endif #if !CYTHON_USE_TYPE_SPECS if (__Pyx_PyType_Ready(__pyx_MemviewEnum_type) < 0) __PYX_ERR(1, 302, __pyx_L1_error) #endif #if PY_MAJOR_VERSION < 3 __pyx_MemviewEnum_type->tp_print = 0; #endif #if !CYTHON_COMPILING_IN_LIMITED_API if ((CYTHON_USE_TYPE_SLOTS && CYTHON_USE_PYTYPE_LOOKUP) && likely(!__pyx_MemviewEnum_type->tp_dictoffset && __pyx_MemviewEnum_type->tp_getattro == PyObject_GenericGetAttr)) { __pyx_MemviewEnum_type->tp_getattro = __Pyx_PyObject_GenericGetAttr; } #endif #if !CYTHON_COMPILING_IN_LIMITED_API if (__Pyx_setup_reduce((PyObject *) __pyx_MemviewEnum_type) < 0) __PYX_ERR(1, 302, __pyx_L1_error) #endif __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; __pyx_vtable_memoryview._get_base = (PyObject *(*)(struct __pyx_memoryview_obj *))__pyx_memoryview__get_base; #if CYTHON_USE_TYPE_SPECS __pyx_memoryview_type = (PyTypeObject *) __Pyx_PyType_FromModuleAndSpec(__pyx_m, &__pyx_type___pyx_memoryview_spec, NULL); if (unlikely(!__pyx_memoryview_type)) __PYX_ERR(1, 337, __pyx_L1_error) #if !CYTHON_COMPILING_IN_LIMITED_API __pyx_memoryview_type->tp_as_buffer = &__pyx_tp_as_buffer_memoryview; if (!__pyx_memoryview_type->tp_as_buffer->bf_releasebuffer && __pyx_memoryview_type->tp_base->tp_as_buffer && __pyx_memoryview_type->tp_base->tp_as_buffer->bf_releasebuffer) { __pyx_memoryview_type->tp_as_buffer->bf_releasebuffer = __pyx_memoryview_type->tp_base->tp_as_buffer->bf_releasebuffer; } #elif defined(Py_bf_getbuffer) && defined(Py_bf_releasebuffer) /* PY_VERSION_HEX >= 0x03090000 || Py_LIMITED_API >= 0x030B0000 */ #elif defined(_MSC_VER) #pragma message ("The buffer protocol is not supported in the Limited C-API < 3.11.") #else #warning "The buffer protocol is not supported in the Limited C-API < 3.11." #endif if (__Pyx_fix_up_extension_type_from_spec(&__pyx_type___pyx_memoryview_spec, __pyx_memoryview_type) < 0) __PYX_ERR(1, 337, __pyx_L1_error) #else __pyx_memoryview_type = &__pyx_type___pyx_memoryview; #endif #if !CYTHON_COMPILING_IN_LIMITED_API #endif #if !CYTHON_USE_TYPE_SPECS if (__Pyx_PyType_Ready(__pyx_memoryview_type) < 0) __PYX_ERR(1, 337, __pyx_L1_error) #endif #if PY_MAJOR_VERSION < 3 __pyx_memoryview_type->tp_print = 0; #endif #if !CYTHON_COMPILING_IN_LIMITED_API if ((CYTHON_USE_TYPE_SLOTS && CYTHON_USE_PYTYPE_LOOKUP) && likely(!__pyx_memoryview_type->tp_dictoffset && __pyx_memoryview_type->tp_getattro == PyObject_GenericGetAttr)) { __pyx_memoryview_type->tp_getattro = __Pyx_PyObject_GenericGetAttr; } #endif if (__Pyx_SetVtable(__pyx_memoryview_type, __pyx_vtabptr_memoryview) < 0) __PYX_ERR(1, 337, __pyx_L1_error) #if !CYTHON_COMPILING_IN_LIMITED_API if (__Pyx_MergeVtables(__pyx_memoryview_type) < 0) __PYX_ERR(1, 337, __pyx_L1_error) #endif #if !CYTHON_COMPILING_IN_LIMITED_API if (__Pyx_setup_reduce((PyObject *) __pyx_memoryview_type) < 0) __PYX_ERR(1, 337, __pyx_L1_error) #endif __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_vtable__memoryviewslice.__pyx_base._get_base = (PyObject *(*)(struct __pyx_memoryview_obj *))__pyx_memoryviewslice__get_base; #if CYTHON_USE_TYPE_SPECS __pyx_t_1 = PyTuple_Pack(1, (PyObject *)__pyx_memoryview_type); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 952, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_memoryviewslice_type = (PyTypeObject *) __Pyx_PyType_FromModuleAndSpec(__pyx_m, &__pyx_type___pyx_memoryviewslice_spec, __pyx_t_1); __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0; if (unlikely(!__pyx_memoryviewslice_type)) __PYX_ERR(1, 952, __pyx_L1_error) if (__Pyx_fix_up_extension_type_from_spec(&__pyx_type___pyx_memoryviewslice_spec, __pyx_memoryviewslice_type) < 0) __PYX_ERR(1, 952, __pyx_L1_error) #else __pyx_memoryviewslice_type = &__pyx_type___pyx_memoryviewslice; #endif #if !CYTHON_COMPILING_IN_LIMITED_API __pyx_memoryviewslice_type->tp_base = __pyx_memoryview_type; #endif #if !CYTHON_USE_TYPE_SPECS if (__Pyx_PyType_Ready(__pyx_memoryviewslice_type) < 0) __PYX_ERR(1, 952, __pyx_L1_error) #endif #if PY_MAJOR_VERSION < 3 __pyx_memoryviewslice_type->tp_print = 0; #endif #if !CYTHON_COMPILING_IN_LIMITED_API if ((CYTHON_USE_TYPE_SLOTS && CYTHON_USE_PYTYPE_LOOKUP) && likely(!__pyx_memoryviewslice_type->tp_dictoffset && __pyx_memoryviewslice_type->tp_getattro == PyObject_GenericGetAttr)) { __pyx_memoryviewslice_type->tp_getattro = __Pyx_PyObject_GenericGetAttr; } #endif if (__Pyx_SetVtable(__pyx_memoryviewslice_type, __pyx_vtabptr__memoryviewslice) < 0) __PYX_ERR(1, 952, __pyx_L1_error) #if !CYTHON_COMPILING_IN_LIMITED_API if (__Pyx_MergeVtables(__pyx_memoryviewslice_type) < 0) __PYX_ERR(1, 952, __pyx_L1_error) #endif #if !CYTHON_COMPILING_IN_LIMITED_API if (__Pyx_setup_reduce((PyObject *) __pyx_memoryviewslice_type) < 0) __PYX_ERR(1, 952, __pyx_L1_error) #endif __Pyx_RefNannyFinishContext(); return 0; __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_1); __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_3_0_10(__pyx_t_1, __Pyx_BUILTIN_MODULE_NAME, "type", #if defined(PYPY_VERSION_NUM) && PYPY_VERSION_NUM < 0x050B0000 sizeof(PyTypeObject), __PYX_GET_STRUCT_ALIGNMENT_3_0_10(PyTypeObject), #elif CYTHON_COMPILING_IN_LIMITED_API sizeof(PyTypeObject), __PYX_GET_STRUCT_ALIGNMENT_3_0_10(PyTypeObject), #else sizeof(PyHeapTypeObject), __PYX_GET_STRUCT_ALIGNMENT_3_0_10(PyHeapTypeObject), #endif __Pyx_ImportType_CheckSize_Warn_3_0_10); 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("numpy"); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 271, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_ptype_5numpy_dtype = __Pyx_ImportType_3_0_10(__pyx_t_1, "numpy", "dtype", sizeof(PyArray_Descr), __PYX_GET_STRUCT_ALIGNMENT_3_0_10(PyArray_Descr),__Pyx_ImportType_CheckSize_Ignore_3_0_10); if (!__pyx_ptype_5numpy_dtype) __PYX_ERR(2, 271, __pyx_L1_error) __pyx_ptype_5numpy_flatiter = __Pyx_ImportType_3_0_10(__pyx_t_1, "numpy", "flatiter", sizeof(PyArrayIterObject), __PYX_GET_STRUCT_ALIGNMENT_3_0_10(PyArrayIterObject),__Pyx_ImportType_CheckSize_Ignore_3_0_10); if (!__pyx_ptype_5numpy_flatiter) __PYX_ERR(2, 316, __pyx_L1_error) __pyx_ptype_5numpy_broadcast = __Pyx_ImportType_3_0_10(__pyx_t_1, "numpy", "broadcast", sizeof(PyArrayMultiIterObject), __PYX_GET_STRUCT_ALIGNMENT_3_0_10(PyArrayMultiIterObject),__Pyx_ImportType_CheckSize_Ignore_3_0_10); if (!__pyx_ptype_5numpy_broadcast) __PYX_ERR(2, 320, __pyx_L1_error) __pyx_ptype_5numpy_ndarray = __Pyx_ImportType_3_0_10(__pyx_t_1, "numpy", "ndarray", sizeof(PyArrayObject), __PYX_GET_STRUCT_ALIGNMENT_3_0_10(PyArrayObject),__Pyx_ImportType_CheckSize_Ignore_3_0_10); if (!__pyx_ptype_5numpy_ndarray) __PYX_ERR(2, 359, __pyx_L1_error) __pyx_ptype_5numpy_generic = __Pyx_ImportType_3_0_10(__pyx_t_1, "numpy", "generic", sizeof(PyObject), __PYX_GET_STRUCT_ALIGNMENT_3_0_10(PyObject),__Pyx_ImportType_CheckSize_Warn_3_0_10); if (!__pyx_ptype_5numpy_generic) __PYX_ERR(2, 848, __pyx_L1_error) __pyx_ptype_5numpy_number = __Pyx_ImportType_3_0_10(__pyx_t_1, "numpy", "number", sizeof(PyObject), __PYX_GET_STRUCT_ALIGNMENT_3_0_10(PyObject),__Pyx_ImportType_CheckSize_Warn_3_0_10); if (!__pyx_ptype_5numpy_number) __PYX_ERR(2, 850, __pyx_L1_error) __pyx_ptype_5numpy_integer = __Pyx_ImportType_3_0_10(__pyx_t_1, "numpy", "integer", sizeof(PyObject), __PYX_GET_STRUCT_ALIGNMENT_3_0_10(PyObject),__Pyx_ImportType_CheckSize_Warn_3_0_10); if (!__pyx_ptype_5numpy_integer) __PYX_ERR(2, 852, __pyx_L1_error) __pyx_ptype_5numpy_signedinteger = __Pyx_ImportType_3_0_10(__pyx_t_1, "numpy", "signedinteger", sizeof(PyObject), __PYX_GET_STRUCT_ALIGNMENT_3_0_10(PyObject),__Pyx_ImportType_CheckSize_Warn_3_0_10); if (!__pyx_ptype_5numpy_signedinteger) __PYX_ERR(2, 854, __pyx_L1_error) __pyx_ptype_5numpy_unsignedinteger = __Pyx_ImportType_3_0_10(__pyx_t_1, "numpy", "unsignedinteger", sizeof(PyObject), __PYX_GET_STRUCT_ALIGNMENT_3_0_10(PyObject),__Pyx_ImportType_CheckSize_Warn_3_0_10); if (!__pyx_ptype_5numpy_unsignedinteger) __PYX_ERR(2, 856, __pyx_L1_error) __pyx_ptype_5numpy_inexact = __Pyx_ImportType_3_0_10(__pyx_t_1, "numpy", "inexact", sizeof(PyObject), __PYX_GET_STRUCT_ALIGNMENT_3_0_10(PyObject),__Pyx_ImportType_CheckSize_Warn_3_0_10); if (!__pyx_ptype_5numpy_inexact) __PYX_ERR(2, 858, __pyx_L1_error) __pyx_ptype_5numpy_floating = __Pyx_ImportType_3_0_10(__pyx_t_1, "numpy", "floating", sizeof(PyObject), __PYX_GET_STRUCT_ALIGNMENT_3_0_10(PyObject),__Pyx_ImportType_CheckSize_Warn_3_0_10); if (!__pyx_ptype_5numpy_floating) __PYX_ERR(2, 860, __pyx_L1_error) __pyx_ptype_5numpy_complexfloating = __Pyx_ImportType_3_0_10(__pyx_t_1, "numpy", "complexfloating", sizeof(PyObject), __PYX_GET_STRUCT_ALIGNMENT_3_0_10(PyObject),__Pyx_ImportType_CheckSize_Warn_3_0_10); if (!__pyx_ptype_5numpy_complexfloating) __PYX_ERR(2, 862, __pyx_L1_error) __pyx_ptype_5numpy_flexible = __Pyx_ImportType_3_0_10(__pyx_t_1, "numpy", "flexible", sizeof(PyObject), __PYX_GET_STRUCT_ALIGNMENT_3_0_10(PyObject),__Pyx_ImportType_CheckSize_Warn_3_0_10); if (!__pyx_ptype_5numpy_flexible) __PYX_ERR(2, 864, __pyx_L1_error) __pyx_ptype_5numpy_character = __Pyx_ImportType_3_0_10(__pyx_t_1, "numpy", "character", sizeof(PyObject), __PYX_GET_STRUCT_ALIGNMENT_3_0_10(PyObject),__Pyx_ImportType_CheckSize_Warn_3_0_10); if (!__pyx_ptype_5numpy_character) __PYX_ERR(2, 866, __pyx_L1_error) __pyx_ptype_5numpy_ufunc = __Pyx_ImportType_3_0_10(__pyx_t_1, "numpy", "ufunc", sizeof(PyUFuncObject), __PYX_GET_STRUCT_ALIGNMENT_3_0_10(PyUFuncObject),__Pyx_ImportType_CheckSize_Ignore_3_0_10); if (!__pyx_ptype_5numpy_ufunc) __PYX_ERR(2, 930, __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 PyObject *__pyx_t_1 = NULL; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("__Pyx_modinit_function_import_code", 0); /*--- Function import code ---*/ __pyx_t_1 = PyImport_ImportModule("astroscrappy.utils.median_utils"); if (!__pyx_t_1) __PYX_ERR(0, 1, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); if (__Pyx_ImportFunction_3_0_10(__pyx_t_1, "cymedian", (void (**)(void))&__pyx_f_12astroscrappy_5utils_12median_utils_cymedian, "float (float *, int)") < 0) __PYX_ERR(0, 1, __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; } #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_astroscrappy(PyObject* module); /*proto*/ static PyModuleDef_Slot __pyx_moduledef_slots[] = { {Py_mod_create, (void*)__pyx_pymod_create}, {Py_mod_exec, (void*)__pyx_pymod_exec_astroscrappy}, {0, NULL} }; #endif #ifdef __cplusplus namespace { struct PyModuleDef __pyx_moduledef = #else static struct PyModuleDef __pyx_moduledef = #endif { PyModuleDef_HEAD_INIT, "astroscrappy", __pyx_k_Name_astroscrappy_The_Speedy_Co, /* m_doc */ #if CYTHON_PEP489_MULTI_PHASE_INIT 0, /* m_size */ #elif CYTHON_USE_MODULE_STATE sizeof(__pyx_mstate), /* 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 #if CYTHON_USE_MODULE_STATE __pyx_m_traverse, /* m_traverse */ __pyx_m_clear, /* m_clear */ NULL /* m_free */ #else NULL, /* m_traverse */ NULL, /* m_clear */ NULL /* m_free */ #endif }; #ifdef __cplusplus } /* anonymous namespace */ #endif #endif #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 initastroscrappy(void) CYTHON_SMALL_CODE; /*proto*/ __Pyx_PyMODINIT_FUNC initastroscrappy(void) #else __Pyx_PyMODINIT_FUNC PyInit_astroscrappy(void) CYTHON_SMALL_CODE; /*proto*/ __Pyx_PyMODINIT_FUNC PyInit_astroscrappy(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; } #if CYTHON_COMPILING_IN_LIMITED_API static CYTHON_SMALL_CODE int __Pyx_copy_spec_to_module(PyObject *spec, PyObject *module, const char* from_name, const char* to_name, int allow_none) #else 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) #endif { PyObject *value = PyObject_GetAttrString(spec, from_name); int result = 0; if (likely(value)) { if (allow_none || value != Py_None) { #if CYTHON_COMPILING_IN_LIMITED_API result = PyModule_AddObject(module, to_name, value); #else result = PyDict_SetItemString(moddict, to_name, value); #endif } 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, PyModuleDef *def) { PyObject *module = NULL, *moddict, *modname; CYTHON_UNUSED_VAR(def); 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; #if CYTHON_COMPILING_IN_LIMITED_API moddict = module; #else moddict = PyModule_GetDict(module); if (unlikely(!moddict)) goto bad; #endif 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_astroscrappy(PyObject *__pyx_pyinit_module) #endif #endif { int stringtab_initialized = 0; #if CYTHON_USE_MODULE_STATE int pystate_addmodule_run = 0; #endif 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; static PyThread_type_lock __pyx_t_8[8]; int __pyx_t_9; PyObject *__pyx_t_10 = NULL; PyObject *__pyx_t_11 = NULL; PyObject *__pyx_t_12 = NULL; PyObject *__pyx_t_13 = NULL; PyObject *__pyx_t_14 = NULL; PyObject *__pyx_t_15 = NULL; PyObject *__pyx_t_16 = NULL; PyObject *__pyx_t_17 = 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 'astroscrappy' 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 /*--- 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("astroscrappy", __pyx_methods, __pyx_k_Name_astroscrappy_The_Speedy_Co, 0, PYTHON_API_VERSION); Py_XINCREF(__pyx_m); if (unlikely(!__pyx_m)) __PYX_ERR(0, 1, __pyx_L1_error) #elif CYTHON_USE_MODULE_STATE __pyx_t_1 = PyModule_Create(&__pyx_moduledef); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1, __pyx_L1_error) { int add_module_result = PyState_AddModule(__pyx_t_1, &__pyx_moduledef); __pyx_t_1 = 0; /* transfer ownership from __pyx_t_1 to "astroscrappy" pseudovariable */ if (unlikely((add_module_result < 0))) __PYX_ERR(0, 1, __pyx_L1_error) pystate_addmodule_run = 1; } #else __pyx_m = PyModule_Create(&__pyx_moduledef); if (unlikely(!__pyx_m)) __PYX_ERR(0, 1, __pyx_L1_error) #endif #endif CYTHON_UNUSED_VAR(__pyx_t_1); __pyx_d = PyModule_GetDict(__pyx_m); if (unlikely(!__pyx_d)) __PYX_ERR(0, 1, __pyx_L1_error) Py_INCREF(__pyx_d); __pyx_b = __Pyx_PyImport_AddModuleRef(__Pyx_BUILTIN_MODULE_NAME); if (unlikely(!__pyx_b)) __PYX_ERR(0, 1, __pyx_L1_error) __pyx_cython_runtime = __Pyx_PyImport_AddModuleRef((const char *) "cython_runtime"); if (unlikely(!__pyx_cython_runtime)) __PYX_ERR(0, 1, __pyx_L1_error) if (PyObject_SetAttrString(__pyx_m, "__builtins__", __pyx_b) < 0) __PYX_ERR(0, 1, __pyx_L1_error) #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_astroscrappy(void)", 0); if (__Pyx_check_binary_version(__PYX_LIMITED_VERSION_HEX, __Pyx_get_runtime_version(), CYTHON_COMPILING_IN_LIMITED_API) < 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(__pyx_m) < 0) __PYX_ERR(0, 1, __pyx_L1_error) #endif #ifdef __Pyx_FusedFunction_USED if (__pyx_FusedFunction_init(__pyx_m) < 0) __PYX_ERR(0, 1, __pyx_L1_error) #endif #ifdef __Pyx_Coroutine_USED if (__pyx_Coroutine_init(__pyx_m) < 0) __PYX_ERR(0, 1, __pyx_L1_error) #endif #ifdef __Pyx_Generator_USED if (__pyx_Generator_init(__pyx_m) < 0) __PYX_ERR(0, 1, __pyx_L1_error) #endif #ifdef __Pyx_AsyncGen_USED if (__pyx_AsyncGen_init(__pyx_m) < 0) __PYX_ERR(0, 1, __pyx_L1_error) #endif #ifdef __Pyx_StopAsyncIteration_USED if (__pyx_StopAsyncIteration_init(__pyx_m) < 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 /*--- Initialize various global constants etc. ---*/ if (__Pyx_InitConstants() < 0) __PYX_ERR(0, 1, __pyx_L1_error) stringtab_initialized = 1; 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_astroscrappy__astroscrappy) { 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, "astroscrappy.astroscrappy")) { if (unlikely((PyDict_SetItemString(modules, "astroscrappy.astroscrappy", __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(); if (unlikely((__Pyx_modinit_function_import_code() < 0))) __PYX_ERR(0, 1, __pyx_L1_error) /*--- Execution code ---*/ #if defined(__Pyx_Generator_USED) || defined(__Pyx_Coroutine_USED) if (__Pyx_patch_abc() < 0) __PYX_ERR(0, 1, __pyx_L1_error) #endif /* "View.MemoryView":99 * * cdef object __pyx_collections_abc_Sequence "__pyx_collections_abc_Sequence" * try: # <<<<<<<<<<<<<< * if __import__("sys").version_info >= (3, 3): * __pyx_collections_abc_Sequence = __import__("collections.abc").abc.Sequence */ { __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:*/ { /* "View.MemoryView":100 * cdef object __pyx_collections_abc_Sequence "__pyx_collections_abc_Sequence" * try: * if __import__("sys").version_info >= (3, 3): # <<<<<<<<<<<<<< * __pyx_collections_abc_Sequence = __import__("collections.abc").abc.Sequence * else: */ __pyx_t_4 = __Pyx_PyObject_Call(__pyx_builtin___import__, __pyx_tuple__17, NULL); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 100, __pyx_L2_error) __Pyx_GOTREF(__pyx_t_4); __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_t_4, __pyx_n_s_version_info); if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 100, __pyx_L2_error) __Pyx_GOTREF(__pyx_t_5); __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __pyx_t_4 = PyObject_RichCompare(__pyx_t_5, __pyx_tuple__18, Py_GE); __Pyx_XGOTREF(__pyx_t_4); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 100, __pyx_L2_error) __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; __pyx_t_6 = __Pyx_PyObject_IsTrue(__pyx_t_4); if (unlikely((__pyx_t_6 < 0))) __PYX_ERR(1, 100, __pyx_L2_error) __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; if (__pyx_t_6) { /* "View.MemoryView":101 * try: * if __import__("sys").version_info >= (3, 3): * __pyx_collections_abc_Sequence = __import__("collections.abc").abc.Sequence # <<<<<<<<<<<<<< * else: * __pyx_collections_abc_Sequence = __import__("collections").Sequence */ __pyx_t_4 = __Pyx_PyObject_Call(__pyx_builtin___import__, __pyx_tuple__19, NULL); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 101, __pyx_L2_error) __Pyx_GOTREF(__pyx_t_4); __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_t_4, __pyx_n_s_abc); if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 101, __pyx_L2_error) __Pyx_GOTREF(__pyx_t_5); __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_t_5, __pyx_n_s_Sequence); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 101, __pyx_L2_error) __Pyx_GOTREF(__pyx_t_4); __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; __Pyx_XGOTREF(__pyx_collections_abc_Sequence); __Pyx_DECREF_SET(__pyx_collections_abc_Sequence, __pyx_t_4); __Pyx_GIVEREF(__pyx_t_4); __pyx_t_4 = 0; /* "View.MemoryView":100 * cdef object __pyx_collections_abc_Sequence "__pyx_collections_abc_Sequence" * try: * if __import__("sys").version_info >= (3, 3): # <<<<<<<<<<<<<< * __pyx_collections_abc_Sequence = __import__("collections.abc").abc.Sequence * else: */ goto __pyx_L8; } /* "View.MemoryView":103 * __pyx_collections_abc_Sequence = __import__("collections.abc").abc.Sequence * else: * __pyx_collections_abc_Sequence = __import__("collections").Sequence # <<<<<<<<<<<<<< * except: * */ /*else*/ { __pyx_t_4 = __Pyx_PyObject_Call(__pyx_builtin___import__, __pyx_tuple__20, NULL); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 103, __pyx_L2_error) __Pyx_GOTREF(__pyx_t_4); __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_t_4, __pyx_n_s_Sequence); if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 103, __pyx_L2_error) __Pyx_GOTREF(__pyx_t_5); __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __Pyx_XGOTREF(__pyx_collections_abc_Sequence); __Pyx_DECREF_SET(__pyx_collections_abc_Sequence, __pyx_t_5); __Pyx_GIVEREF(__pyx_t_5); __pyx_t_5 = 0; } __pyx_L8:; /* "View.MemoryView":99 * * cdef object __pyx_collections_abc_Sequence "__pyx_collections_abc_Sequence" * try: # <<<<<<<<<<<<<< * if __import__("sys").version_info >= (3, 3): * __pyx_collections_abc_Sequence = __import__("collections.abc").abc.Sequence */ } __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_L7_try_end; __pyx_L2_error:; __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0; /* "View.MemoryView":104 * else: * __pyx_collections_abc_Sequence = __import__("collections").Sequence * except: # <<<<<<<<<<<<<< * * __pyx_collections_abc_Sequence = None */ /*except:*/ { __Pyx_AddTraceback("View.MemoryView", __pyx_clineno, __pyx_lineno, __pyx_filename); if (__Pyx_GetException(&__pyx_t_5, &__pyx_t_4, &__pyx_t_7) < 0) __PYX_ERR(1, 104, __pyx_L4_except_error) __Pyx_XGOTREF(__pyx_t_5); __Pyx_XGOTREF(__pyx_t_4); __Pyx_XGOTREF(__pyx_t_7); /* "View.MemoryView":106 * except: * * __pyx_collections_abc_Sequence = None # <<<<<<<<<<<<<< * * */ __Pyx_INCREF(Py_None); __Pyx_XGOTREF(__pyx_collections_abc_Sequence); __Pyx_DECREF_SET(__pyx_collections_abc_Sequence, Py_None); __Pyx_GIVEREF(Py_None); __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0; __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; goto __pyx_L3_exception_handled; } /* "View.MemoryView":99 * * cdef object __pyx_collections_abc_Sequence "__pyx_collections_abc_Sequence" * try: # <<<<<<<<<<<<<< * if __import__("sys").version_info >= (3, 3): * __pyx_collections_abc_Sequence = __import__("collections.abc").abc.Sequence */ __pyx_L4_except_error:; __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_L3_exception_handled:; __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); __pyx_L7_try_end:; } /* "View.MemoryView":241 * * * try: # <<<<<<<<<<<<<< * count = __pyx_collections_abc_Sequence.count * index = __pyx_collections_abc_Sequence.index */ { __Pyx_PyThreadState_declare __Pyx_PyThreadState_assign __Pyx_ExceptionSave(&__pyx_t_3, &__pyx_t_2, &__pyx_t_1); __Pyx_XGOTREF(__pyx_t_3); __Pyx_XGOTREF(__pyx_t_2); __Pyx_XGOTREF(__pyx_t_1); /*try:*/ { /* "View.MemoryView":242 * * try: * count = __pyx_collections_abc_Sequence.count # <<<<<<<<<<<<<< * index = __pyx_collections_abc_Sequence.index * except: */ __pyx_t_7 = __Pyx_PyObject_GetAttrStr(__pyx_collections_abc_Sequence, __pyx_n_s_count); if (unlikely(!__pyx_t_7)) __PYX_ERR(1, 242, __pyx_L11_error) __Pyx_GOTREF(__pyx_t_7); if (__Pyx_SetItemOnTypeDict(__pyx_array_type, __pyx_n_s_count, __pyx_t_7) < 0) __PYX_ERR(1, 242, __pyx_L11_error) __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; PyType_Modified(__pyx_array_type); /* "View.MemoryView":243 * try: * count = __pyx_collections_abc_Sequence.count * index = __pyx_collections_abc_Sequence.index # <<<<<<<<<<<<<< * except: * pass */ __pyx_t_7 = __Pyx_PyObject_GetAttrStr(__pyx_collections_abc_Sequence, __pyx_n_s_index); if (unlikely(!__pyx_t_7)) __PYX_ERR(1, 243, __pyx_L11_error) __Pyx_GOTREF(__pyx_t_7); if (__Pyx_SetItemOnTypeDict(__pyx_array_type, __pyx_n_s_index, __pyx_t_7) < 0) __PYX_ERR(1, 243, __pyx_L11_error) __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; PyType_Modified(__pyx_array_type); /* "View.MemoryView":241 * * * try: # <<<<<<<<<<<<<< * count = __pyx_collections_abc_Sequence.count * index = __pyx_collections_abc_Sequence.index */ } __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0; __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0; goto __pyx_L16_try_end; __pyx_L11_error:; __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0; __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; /* "View.MemoryView":244 * count = __pyx_collections_abc_Sequence.count * index = __pyx_collections_abc_Sequence.index * except: # <<<<<<<<<<<<<< * pass * */ /*except:*/ { __Pyx_ErrRestore(0,0,0); goto __pyx_L12_exception_handled; } __pyx_L12_exception_handled:; __Pyx_XGIVEREF(__pyx_t_3); __Pyx_XGIVEREF(__pyx_t_2); __Pyx_XGIVEREF(__pyx_t_1); __Pyx_ExceptionReset(__pyx_t_3, __pyx_t_2, __pyx_t_1); __pyx_L16_try_end:; } /* "View.MemoryView":309 * return self.name * * cdef generic = Enum("") # <<<<<<<<<<<<<< * cdef strided = Enum("") # default * cdef indirect = Enum("") */ __pyx_t_7 = __Pyx_PyObject_Call(((PyObject *)__pyx_MemviewEnum_type), __pyx_tuple__21, NULL); if (unlikely(!__pyx_t_7)) __PYX_ERR(1, 309, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_7); __Pyx_XGOTREF(generic); __Pyx_DECREF_SET(generic, __pyx_t_7); __Pyx_GIVEREF(__pyx_t_7); __pyx_t_7 = 0; /* "View.MemoryView":310 * * cdef generic = Enum("") * cdef strided = Enum("") # default # <<<<<<<<<<<<<< * cdef indirect = Enum("") * */ __pyx_t_7 = __Pyx_PyObject_Call(((PyObject *)__pyx_MemviewEnum_type), __pyx_tuple__22, NULL); if (unlikely(!__pyx_t_7)) __PYX_ERR(1, 310, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_7); __Pyx_XGOTREF(strided); __Pyx_DECREF_SET(strided, __pyx_t_7); __Pyx_GIVEREF(__pyx_t_7); __pyx_t_7 = 0; /* "View.MemoryView":311 * cdef generic = Enum("") * cdef strided = Enum("") # default * cdef indirect = Enum("") # <<<<<<<<<<<<<< * * */ __pyx_t_7 = __Pyx_PyObject_Call(((PyObject *)__pyx_MemviewEnum_type), __pyx_tuple__23, NULL); if (unlikely(!__pyx_t_7)) __PYX_ERR(1, 311, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_7); __Pyx_XGOTREF(indirect); __Pyx_DECREF_SET(indirect, __pyx_t_7); __Pyx_GIVEREF(__pyx_t_7); __pyx_t_7 = 0; /* "View.MemoryView":314 * * * cdef contiguous = Enum("") # <<<<<<<<<<<<<< * cdef indirect_contiguous = Enum("") * */ __pyx_t_7 = __Pyx_PyObject_Call(((PyObject *)__pyx_MemviewEnum_type), __pyx_tuple__24, NULL); if (unlikely(!__pyx_t_7)) __PYX_ERR(1, 314, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_7); __Pyx_XGOTREF(contiguous); __Pyx_DECREF_SET(contiguous, __pyx_t_7); __Pyx_GIVEREF(__pyx_t_7); __pyx_t_7 = 0; /* "View.MemoryView":315 * * cdef contiguous = Enum("") * cdef indirect_contiguous = Enum("") # <<<<<<<<<<<<<< * * */ __pyx_t_7 = __Pyx_PyObject_Call(((PyObject *)__pyx_MemviewEnum_type), __pyx_tuple__25, NULL); if (unlikely(!__pyx_t_7)) __PYX_ERR(1, 315, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_7); __Pyx_XGOTREF(indirect_contiguous); __Pyx_DECREF_SET(indirect_contiguous, __pyx_t_7); __Pyx_GIVEREF(__pyx_t_7); __pyx_t_7 = 0; /* "View.MemoryView":323 * * * cdef int __pyx_memoryview_thread_locks_used = 0 # <<<<<<<<<<<<<< * cdef PyThread_type_lock[8] __pyx_memoryview_thread_locks = [ * PyThread_allocate_lock(), */ __pyx_memoryview_thread_locks_used = 0; /* "View.MemoryView":324 * * cdef int __pyx_memoryview_thread_locks_used = 0 * cdef PyThread_type_lock[8] __pyx_memoryview_thread_locks = [ # <<<<<<<<<<<<<< * PyThread_allocate_lock(), * PyThread_allocate_lock(), */ __pyx_t_8[0] = PyThread_allocate_lock(); __pyx_t_8[1] = PyThread_allocate_lock(); __pyx_t_8[2] = PyThread_allocate_lock(); __pyx_t_8[3] = PyThread_allocate_lock(); __pyx_t_8[4] = PyThread_allocate_lock(); __pyx_t_8[5] = PyThread_allocate_lock(); __pyx_t_8[6] = PyThread_allocate_lock(); __pyx_t_8[7] = PyThread_allocate_lock(); memcpy(&(__pyx_memoryview_thread_locks[0]), __pyx_t_8, sizeof(__pyx_memoryview_thread_locks[0]) * (8)); /* "View.MemoryView":982 * * * try: # <<<<<<<<<<<<<< * count = __pyx_collections_abc_Sequence.count * index = __pyx_collections_abc_Sequence.index */ { __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:*/ { /* "View.MemoryView":983 * * try: * count = __pyx_collections_abc_Sequence.count # <<<<<<<<<<<<<< * index = __pyx_collections_abc_Sequence.index * except: */ __pyx_t_7 = __Pyx_PyObject_GetAttrStr(__pyx_collections_abc_Sequence, __pyx_n_s_count); if (unlikely(!__pyx_t_7)) __PYX_ERR(1, 983, __pyx_L17_error) __Pyx_GOTREF(__pyx_t_7); if (__Pyx_SetItemOnTypeDict(__pyx_memoryviewslice_type, __pyx_n_s_count, __pyx_t_7) < 0) __PYX_ERR(1, 983, __pyx_L17_error) __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; PyType_Modified(__pyx_memoryviewslice_type); /* "View.MemoryView":984 * try: * count = __pyx_collections_abc_Sequence.count * index = __pyx_collections_abc_Sequence.index # <<<<<<<<<<<<<< * except: * pass */ __pyx_t_7 = __Pyx_PyObject_GetAttrStr(__pyx_collections_abc_Sequence, __pyx_n_s_index); if (unlikely(!__pyx_t_7)) __PYX_ERR(1, 984, __pyx_L17_error) __Pyx_GOTREF(__pyx_t_7); if (__Pyx_SetItemOnTypeDict(__pyx_memoryviewslice_type, __pyx_n_s_index, __pyx_t_7) < 0) __PYX_ERR(1, 984, __pyx_L17_error) __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; PyType_Modified(__pyx_memoryviewslice_type); /* "View.MemoryView":982 * * * try: # <<<<<<<<<<<<<< * count = __pyx_collections_abc_Sequence.count * index = __pyx_collections_abc_Sequence.index */ } __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_L22_try_end; __pyx_L17_error:; __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0; __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; /* "View.MemoryView":985 * count = __pyx_collections_abc_Sequence.count * index = __pyx_collections_abc_Sequence.index * except: # <<<<<<<<<<<<<< * pass * */ /*except:*/ { __Pyx_ErrRestore(0,0,0); goto __pyx_L18_exception_handled; } __pyx_L18_exception_handled:; __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); __pyx_L22_try_end:; } /* "View.MemoryView":988 * pass * * try: # <<<<<<<<<<<<<< * if __pyx_collections_abc_Sequence: * */ { __Pyx_PyThreadState_declare __Pyx_PyThreadState_assign __Pyx_ExceptionSave(&__pyx_t_3, &__pyx_t_2, &__pyx_t_1); __Pyx_XGOTREF(__pyx_t_3); __Pyx_XGOTREF(__pyx_t_2); __Pyx_XGOTREF(__pyx_t_1); /*try:*/ { /* "View.MemoryView":989 * * try: * if __pyx_collections_abc_Sequence: # <<<<<<<<<<<<<< * * */ __pyx_t_6 = __Pyx_PyObject_IsTrue(__pyx_collections_abc_Sequence); if (unlikely((__pyx_t_6 < 0))) __PYX_ERR(1, 989, __pyx_L23_error) if (__pyx_t_6) { /* "View.MemoryView":993 * * * __pyx_collections_abc_Sequence.register(_memoryviewslice) # <<<<<<<<<<<<<< * __pyx_collections_abc_Sequence.register(array) * except: */ __pyx_t_7 = __Pyx_PyObject_GetAttrStr(__pyx_collections_abc_Sequence, __pyx_n_s_register); if (unlikely(!__pyx_t_7)) __PYX_ERR(1, 993, __pyx_L23_error) __Pyx_GOTREF(__pyx_t_7); __pyx_t_4 = __Pyx_PyObject_CallOneArg(__pyx_t_7, ((PyObject *)__pyx_memoryviewslice_type)); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 993, __pyx_L23_error) __Pyx_GOTREF(__pyx_t_4); __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; /* "View.MemoryView":994 * * __pyx_collections_abc_Sequence.register(_memoryviewslice) * __pyx_collections_abc_Sequence.register(array) # <<<<<<<<<<<<<< * except: * pass # ignore failure, it's a minor issue */ __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_collections_abc_Sequence, __pyx_n_s_register); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 994, __pyx_L23_error) __Pyx_GOTREF(__pyx_t_4); __pyx_t_7 = __Pyx_PyObject_CallOneArg(__pyx_t_4, ((PyObject *)__pyx_array_type)); if (unlikely(!__pyx_t_7)) __PYX_ERR(1, 994, __pyx_L23_error) __Pyx_GOTREF(__pyx_t_7); __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; /* "View.MemoryView":989 * * try: * if __pyx_collections_abc_Sequence: # <<<<<<<<<<<<<< * * */ } /* "View.MemoryView":988 * pass * * try: # <<<<<<<<<<<<<< * if __pyx_collections_abc_Sequence: * */ } __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0; __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0; goto __pyx_L28_try_end; __pyx_L23_error:; __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0; __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; /* "View.MemoryView":995 * __pyx_collections_abc_Sequence.register(_memoryviewslice) * __pyx_collections_abc_Sequence.register(array) * except: # <<<<<<<<<<<<<< * pass # ignore failure, it's a minor issue * */ /*except:*/ { __Pyx_ErrRestore(0,0,0); goto __pyx_L24_exception_handled; } __pyx_L24_exception_handled:; __Pyx_XGIVEREF(__pyx_t_3); __Pyx_XGIVEREF(__pyx_t_2); __Pyx_XGIVEREF(__pyx_t_1); __Pyx_ExceptionReset(__pyx_t_3, __pyx_t_2, __pyx_t_1); __pyx_L28_try_end:; } /* "(tree fragment)":1 * def __pyx_unpickle_Enum(__pyx_type, long __pyx_checksum, __pyx_state): # <<<<<<<<<<<<<< * cdef object __pyx_PickleError * cdef object __pyx_result */ __pyx_t_7 = PyCFunction_NewEx(&__pyx_mdef_15View_dot_MemoryView_1__pyx_unpickle_Enum, NULL, __pyx_n_s_View_MemoryView); if (unlikely(!__pyx_t_7)) __PYX_ERR(1, 1, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_7); if (PyDict_SetItem(__pyx_d, __pyx_n_s_pyx_unpickle_Enum, __pyx_t_7) < 0) __PYX_ERR(1, 1, __pyx_L1_error) __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; /* "astroscrappy/astroscrappy.pyx":9 * """ * * import numpy as np # <<<<<<<<<<<<<< * cimport numpy as np * */ __pyx_t_7 = __Pyx_ImportDottedModule(__pyx_n_s_numpy, NULL); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 9, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_7); if (PyDict_SetItem(__pyx_d, __pyx_n_s_np, __pyx_t_7) < 0) __PYX_ERR(0, 9, __pyx_L1_error) __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; /* "astroscrappy/astroscrappy.pyx":12 * cimport numpy as np * * np.import_array() # <<<<<<<<<<<<<< * * cimport cython */ __pyx_t_9 = __pyx_f_5numpy_import_array(); if (unlikely(__pyx_t_9 == ((int)-1))) __PYX_ERR(0, 12, __pyx_L1_error) /* "astroscrappy/astroscrappy.pyx":17 * from cython.parallel cimport parallel, prange * * from .utils import * # <<<<<<<<<<<<<< * from .utils.median_utils cimport cymedian * */ __pyx_t_7 = PyList_New(1); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 17, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_7); __Pyx_INCREF(__pyx_n_s__3); __Pyx_GIVEREF(__pyx_n_s__3); if (__Pyx_PyList_SET_ITEM(__pyx_t_7, 0, __pyx_n_s__3)) __PYX_ERR(0, 17, __pyx_L1_error); __pyx_t_4 = __Pyx_Import(__pyx_n_s_utils, __pyx_t_7, 1); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 17, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; if (__pyx_import_star(__pyx_t_4) < 0) __PYX_ERR(0, 17, __pyx_L1_error); __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; /* "astroscrappy/astroscrappy.pyx":26 * from libc.stdlib cimport malloc, free * * def detect_cosmics(indat, inmask=None, inbkg=None, invar=None, float sigclip=4.5, # <<<<<<<<<<<<<< * float sigfrac=0.3, float objlim=5.0, float gain=1.0, * float readnoise=6.5, float satlevel=65536.0, */ __pyx_t_4 = PyFloat_FromDouble(((double)4.5)); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 26, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); /* "astroscrappy/astroscrappy.pyx":27 * * def detect_cosmics(indat, inmask=None, inbkg=None, invar=None, float sigclip=4.5, * float sigfrac=0.3, float objlim=5.0, float gain=1.0, # <<<<<<<<<<<<<< * float readnoise=6.5, float satlevel=65536.0, * int niter=4, sepmed=True, cleantype='meanmask', */ __pyx_t_7 = PyFloat_FromDouble(((double)0.3)); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 27, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_7); __pyx_t_5 = PyFloat_FromDouble(((double)5.0)); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 27, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_5); __pyx_t_10 = PyFloat_FromDouble(((double)1.0)); if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 27, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_10); /* "astroscrappy/astroscrappy.pyx":28 * def detect_cosmics(indat, inmask=None, inbkg=None, invar=None, float sigclip=4.5, * float sigfrac=0.3, float objlim=5.0, float gain=1.0, * float readnoise=6.5, float satlevel=65536.0, # <<<<<<<<<<<<<< * int niter=4, sepmed=True, cleantype='meanmask', * fsmode='median', psfmodel='gauss', float psffwhm=2.5, */ __pyx_t_11 = PyFloat_FromDouble(((double)6.5)); if (unlikely(!__pyx_t_11)) __PYX_ERR(0, 28, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_11); __pyx_t_12 = PyFloat_FromDouble(((double)65536.0)); if (unlikely(!__pyx_t_12)) __PYX_ERR(0, 28, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_12); /* "astroscrappy/astroscrappy.pyx":29 * float sigfrac=0.3, float objlim=5.0, float gain=1.0, * float readnoise=6.5, float satlevel=65536.0, * int niter=4, sepmed=True, cleantype='meanmask', # <<<<<<<<<<<<<< * fsmode='median', psfmodel='gauss', float psffwhm=2.5, * int psfsize=7, psfk=None, float psfbeta=4.765, */ __pyx_t_13 = __Pyx_PyInt_From_int(((int)4)); if (unlikely(!__pyx_t_13)) __PYX_ERR(0, 29, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_13); /* "astroscrappy/astroscrappy.pyx":30 * float readnoise=6.5, float satlevel=65536.0, * int niter=4, sepmed=True, cleantype='meanmask', * fsmode='median', psfmodel='gauss', float psffwhm=2.5, # <<<<<<<<<<<<<< * int psfsize=7, psfk=None, float psfbeta=4.765, * verbose=False): */ __pyx_t_14 = PyFloat_FromDouble(((double)2.5)); if (unlikely(!__pyx_t_14)) __PYX_ERR(0, 30, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_14); /* "astroscrappy/astroscrappy.pyx":31 * int niter=4, sepmed=True, cleantype='meanmask', * fsmode='median', psfmodel='gauss', float psffwhm=2.5, * int psfsize=7, psfk=None, float psfbeta=4.765, # <<<<<<<<<<<<<< * verbose=False): * """detect_cosmics(indat, inmask=None, inbkg=None, invar=None, sigclip=4.5, */ __pyx_t_15 = __Pyx_PyInt_From_int(((int)7)); if (unlikely(!__pyx_t_15)) __PYX_ERR(0, 31, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_15); __pyx_t_16 = PyFloat_FromDouble(((double)4.765)); if (unlikely(!__pyx_t_16)) __PYX_ERR(0, 31, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_16); /* "astroscrappy/astroscrappy.pyx":26 * from libc.stdlib cimport malloc, free * * def detect_cosmics(indat, inmask=None, inbkg=None, invar=None, float sigclip=4.5, # <<<<<<<<<<<<<< * float sigfrac=0.3, float objlim=5.0, float gain=1.0, * float readnoise=6.5, float satlevel=65536.0, */ __pyx_t_17 = PyTuple_New(19); if (unlikely(!__pyx_t_17)) __PYX_ERR(0, 26, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_17); __Pyx_INCREF(Py_None); __Pyx_GIVEREF(Py_None); if (__Pyx_PyTuple_SET_ITEM(__pyx_t_17, 0, Py_None)) __PYX_ERR(0, 26, __pyx_L1_error); __Pyx_INCREF(Py_None); __Pyx_GIVEREF(Py_None); if (__Pyx_PyTuple_SET_ITEM(__pyx_t_17, 1, Py_None)) __PYX_ERR(0, 26, __pyx_L1_error); __Pyx_INCREF(Py_None); __Pyx_GIVEREF(Py_None); if (__Pyx_PyTuple_SET_ITEM(__pyx_t_17, 2, Py_None)) __PYX_ERR(0, 26, __pyx_L1_error); __Pyx_GIVEREF(__pyx_t_4); if (__Pyx_PyTuple_SET_ITEM(__pyx_t_17, 3, __pyx_t_4)) __PYX_ERR(0, 26, __pyx_L1_error); __Pyx_GIVEREF(__pyx_t_7); if (__Pyx_PyTuple_SET_ITEM(__pyx_t_17, 4, __pyx_t_7)) __PYX_ERR(0, 26, __pyx_L1_error); __Pyx_GIVEREF(__pyx_t_5); if (__Pyx_PyTuple_SET_ITEM(__pyx_t_17, 5, __pyx_t_5)) __PYX_ERR(0, 26, __pyx_L1_error); __Pyx_GIVEREF(__pyx_t_10); if (__Pyx_PyTuple_SET_ITEM(__pyx_t_17, 6, __pyx_t_10)) __PYX_ERR(0, 26, __pyx_L1_error); __Pyx_GIVEREF(__pyx_t_11); if (__Pyx_PyTuple_SET_ITEM(__pyx_t_17, 7, __pyx_t_11)) __PYX_ERR(0, 26, __pyx_L1_error); __Pyx_GIVEREF(__pyx_t_12); if (__Pyx_PyTuple_SET_ITEM(__pyx_t_17, 8, __pyx_t_12)) __PYX_ERR(0, 26, __pyx_L1_error); __Pyx_GIVEREF(__pyx_t_13); if (__Pyx_PyTuple_SET_ITEM(__pyx_t_17, 9, __pyx_t_13)) __PYX_ERR(0, 26, __pyx_L1_error); __Pyx_INCREF(((PyObject *)Py_True)); __Pyx_GIVEREF(((PyObject *)Py_True)); if (__Pyx_PyTuple_SET_ITEM(__pyx_t_17, 10, ((PyObject *)Py_True))) __PYX_ERR(0, 26, __pyx_L1_error); __Pyx_INCREF(((PyObject*)__pyx_n_u_meanmask)); __Pyx_GIVEREF(((PyObject*)__pyx_n_u_meanmask)); if (__Pyx_PyTuple_SET_ITEM(__pyx_t_17, 11, ((PyObject*)__pyx_n_u_meanmask))) __PYX_ERR(0, 26, __pyx_L1_error); __Pyx_INCREF(((PyObject*)__pyx_n_u_median)); __Pyx_GIVEREF(((PyObject*)__pyx_n_u_median)); if (__Pyx_PyTuple_SET_ITEM(__pyx_t_17, 12, ((PyObject*)__pyx_n_u_median))) __PYX_ERR(0, 26, __pyx_L1_error); __Pyx_INCREF(((PyObject*)__pyx_n_u_gauss)); __Pyx_GIVEREF(((PyObject*)__pyx_n_u_gauss)); if (__Pyx_PyTuple_SET_ITEM(__pyx_t_17, 13, ((PyObject*)__pyx_n_u_gauss))) __PYX_ERR(0, 26, __pyx_L1_error); __Pyx_GIVEREF(__pyx_t_14); if (__Pyx_PyTuple_SET_ITEM(__pyx_t_17, 14, __pyx_t_14)) __PYX_ERR(0, 26, __pyx_L1_error); __Pyx_GIVEREF(__pyx_t_15); if (__Pyx_PyTuple_SET_ITEM(__pyx_t_17, 15, __pyx_t_15)) __PYX_ERR(0, 26, __pyx_L1_error); __Pyx_INCREF(Py_None); __Pyx_GIVEREF(Py_None); if (__Pyx_PyTuple_SET_ITEM(__pyx_t_17, 16, Py_None)) __PYX_ERR(0, 26, __pyx_L1_error); __Pyx_GIVEREF(__pyx_t_16); if (__Pyx_PyTuple_SET_ITEM(__pyx_t_17, 17, __pyx_t_16)) __PYX_ERR(0, 26, __pyx_L1_error); __Pyx_INCREF(((PyObject *)Py_False)); __Pyx_GIVEREF(((PyObject *)Py_False)); if (__Pyx_PyTuple_SET_ITEM(__pyx_t_17, 18, ((PyObject *)Py_False))) __PYX_ERR(0, 26, __pyx_L1_error); __pyx_t_4 = 0; __pyx_t_7 = 0; __pyx_t_5 = 0; __pyx_t_10 = 0; __pyx_t_11 = 0; __pyx_t_12 = 0; __pyx_t_13 = 0; __pyx_t_14 = 0; __pyx_t_15 = 0; __pyx_t_16 = 0; __pyx_t_16 = __Pyx_CyFunction_New(&__pyx_mdef_12astroscrappy_12astroscrappy_1detect_cosmics, 0, __pyx_n_s_detect_cosmics, NULL, __pyx_n_s_astroscrappy_astroscrappy, __pyx_d, ((PyObject *)__pyx_codeobj__29)); if (unlikely(!__pyx_t_16)) __PYX_ERR(0, 26, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_16); __Pyx_CyFunction_SetDefaultsTuple(__pyx_t_16, __pyx_t_17); __Pyx_DECREF(__pyx_t_17); __pyx_t_17 = 0; if (PyDict_SetItem(__pyx_d, __pyx_n_s_detect_cosmics, __pyx_t_16) < 0) __PYX_ERR(0, 26, __pyx_L1_error) __Pyx_DECREF(__pyx_t_16); __pyx_t_16 = 0; /* "astroscrappy/astroscrappy.pyx":431 * * * def update_mask(np.ndarray[np.float32_t, ndim=2, mode='c', cast=True] data, # <<<<<<<<<<<<<< * np.ndarray[np.uint8_t, ndim=2, mode='c', cast=True] mask, * float satlevel, bool sepmed): */ __pyx_t_16 = __Pyx_CyFunction_New(&__pyx_mdef_12astroscrappy_12astroscrappy_3update_mask, 0, __pyx_n_s_update_mask, NULL, __pyx_n_s_astroscrappy_astroscrappy, __pyx_d, ((PyObject *)__pyx_codeobj__31)); if (unlikely(!__pyx_t_16)) __PYX_ERR(0, 431, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_16); if (PyDict_SetItem(__pyx_d, __pyx_n_s_update_mask, __pyx_t_16) < 0) __PYX_ERR(0, 431, __pyx_L1_error) __Pyx_DECREF(__pyx_t_16); __pyx_t_16 = 0; /* "astroscrappy/astroscrappy.pyx":727 * * * def gausskernel(float psffwhm, int kernsize): # <<<<<<<<<<<<<< * """gausskernel(psffwhm, kernsize)\n * Calculate a circular Gaussian psf kernel. */ __pyx_t_16 = __Pyx_CyFunction_New(&__pyx_mdef_12astroscrappy_12astroscrappy_5gausskernel, 0, __pyx_n_s_gausskernel, NULL, __pyx_n_s_astroscrappy_astroscrappy, __pyx_d, ((PyObject *)__pyx_codeobj__33)); if (unlikely(!__pyx_t_16)) __PYX_ERR(0, 727, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_16); if (PyDict_SetItem(__pyx_d, __pyx_n_s_gausskernel, __pyx_t_16) < 0) __PYX_ERR(0, 727, __pyx_L1_error) __Pyx_DECREF(__pyx_t_16); __pyx_t_16 = 0; /* "astroscrappy/astroscrappy.pyx":759 * * * def gaussxkernel(float psffwhm, int kernsize): # <<<<<<<<<<<<<< * """gaussxkernel(psffwhm, kernsize)\n * Calculate a Gaussian kernel in the x-direction. */ __pyx_t_16 = __Pyx_CyFunction_New(&__pyx_mdef_12astroscrappy_12astroscrappy_7gaussxkernel, 0, __pyx_n_s_gaussxkernel, NULL, __pyx_n_s_astroscrappy_astroscrappy, __pyx_d, ((PyObject *)__pyx_codeobj__35)); if (unlikely(!__pyx_t_16)) __PYX_ERR(0, 759, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_16); if (PyDict_SetItem(__pyx_d, __pyx_n_s_gaussxkernel, __pyx_t_16) < 0) __PYX_ERR(0, 759, __pyx_L1_error) __Pyx_DECREF(__pyx_t_16); __pyx_t_16 = 0; /* "astroscrappy/astroscrappy.pyx":790 * * * def gaussykernel(float psffwhm, int kernsize): # <<<<<<<<<<<<<< * """gaussykernel(psffwhm, kernsize)\n * Calculate a Gaussian kernel in the y-direction. */ __pyx_t_16 = __Pyx_CyFunction_New(&__pyx_mdef_12astroscrappy_12astroscrappy_9gaussykernel, 0, __pyx_n_s_gaussykernel, NULL, __pyx_n_s_astroscrappy_astroscrappy, __pyx_d, ((PyObject *)__pyx_codeobj__37)); if (unlikely(!__pyx_t_16)) __PYX_ERR(0, 790, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_16); if (PyDict_SetItem(__pyx_d, __pyx_n_s_gaussykernel, __pyx_t_16) < 0) __PYX_ERR(0, 790, __pyx_L1_error) __Pyx_DECREF(__pyx_t_16); __pyx_t_16 = 0; /* "astroscrappy/astroscrappy.pyx":1 * # Licensed under a 3-clause BSD style license - see LICENSE.rst # <<<<<<<<<<<<<< * # cython: boundscheck=False, nonecheck=False, wraparound=False, language_level=3, cdivision=True * """ */ __pyx_t_16 = __Pyx_PyDict_NewPresized(0); if (unlikely(!__pyx_t_16)) __PYX_ERR(0, 1, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_16); if (PyDict_SetItem(__pyx_d, __pyx_n_s_test, __pyx_t_16) < 0) __PYX_ERR(0, 1, __pyx_L1_error) __Pyx_DECREF(__pyx_t_16); __pyx_t_16 = 0; /*--- Wrapped vars code ---*/ goto __pyx_L0; __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_4); __Pyx_XDECREF(__pyx_t_5); __Pyx_XDECREF(__pyx_t_7); __Pyx_XDECREF(__pyx_t_10); __Pyx_XDECREF(__pyx_t_11); __Pyx_XDECREF(__pyx_t_12); __Pyx_XDECREF(__pyx_t_13); __Pyx_XDECREF(__pyx_t_14); __Pyx_XDECREF(__pyx_t_15); __Pyx_XDECREF(__pyx_t_16); __Pyx_XDECREF(__pyx_t_17); if (__pyx_m) { if (__pyx_d && stringtab_initialized) { __Pyx_AddTraceback("init astroscrappy.astroscrappy", __pyx_clineno, __pyx_lineno, __pyx_filename); } #if !CYTHON_USE_MODULE_STATE Py_CLEAR(__pyx_m); #else Py_DECREF(__pyx_m); if (pystate_addmodule_run) { PyObject *tp, *value, *tb; PyErr_Fetch(&tp, &value, &tb); PyState_RemoveModule(&__pyx_moduledef); PyErr_Restore(tp, value, tb); } #endif } else if (!PyErr_Occurred()) { PyErr_SetString(PyExc_ImportError, "init astroscrappy.astroscrappy"); } __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 } /* #### Code section: cleanup_globals ### */ /* #### Code section: cleanup_module ### */ /* #### Code section: main_method ### */ /* #### Code section: utility_code_pragmas ### */ #ifdef _MSC_VER #pragma warning( push ) /* Warning 4127: conditional expression is constant * Cython uses constant conditional expressions to allow in inline functions to be optimized at * compile-time, so this warning is not useful */ #pragma warning( disable : 4127 ) #endif /* #### Code section: utility_code_def ### */ /* --- 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 /* 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; i= 0x030C00A6 PyObject *current_exception = tstate->current_exception; if (unlikely(!current_exception)) return 0; exc_type = (PyObject*) Py_TYPE(current_exception); if (exc_type == err) return 1; #else exc_type = tstate->curexc_type; if (exc_type == err) return 1; if (unlikely(!exc_type)) return 0; #endif #if CYTHON_AVOID_BORROWED_REFS Py_INCREF(exc_type); #endif if (unlikely(PyTuple_Check(err))) { result = __Pyx_PyErr_ExceptionMatchesTuple(exc_type, err); } else { result = __Pyx_PyErr_GivenExceptionMatches(exc_type, err); } #if CYTHON_AVOID_BORROWED_REFS Py_DECREF(exc_type); #endif return result; } #endif /* PyErrFetchRestore */ #if CYTHON_FAST_THREAD_STATE static CYTHON_INLINE void __Pyx_ErrRestoreInState(PyThreadState *tstate, PyObject *type, PyObject *value, PyObject *tb) { #if PY_VERSION_HEX >= 0x030C00A6 PyObject *tmp_value; assert(type == NULL || (value != NULL && type == (PyObject*) Py_TYPE(value))); if (value) { #if CYTHON_COMPILING_IN_CPYTHON if (unlikely(((PyBaseExceptionObject*) value)->traceback != tb)) #endif PyException_SetTraceback(value, tb); } tmp_value = tstate->current_exception; tstate->current_exception = value; Py_XDECREF(tmp_value); Py_XDECREF(type); Py_XDECREF(tb); #else 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); #endif } static CYTHON_INLINE void __Pyx_ErrFetchInState(PyThreadState *tstate, PyObject **type, PyObject **value, PyObject **tb) { #if PY_VERSION_HEX >= 0x030C00A6 PyObject* exc_value; exc_value = tstate->current_exception; tstate->current_exception = 0; *value = exc_value; *type = NULL; *tb = NULL; if (exc_value) { *type = (PyObject*) Py_TYPE(exc_value); Py_INCREF(*type); #if CYTHON_COMPILING_IN_CPYTHON *tb = ((PyBaseExceptionObject*) exc_value)->traceback; Py_XINCREF(*tb); #else *tb = PyException_GetTraceback(exc_value); #endif } #else *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 } #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 /* PyObjectGetAttrStrNoError */ #if __PYX_LIMITED_VERSION_HEX < 0x030d00A1 static void __Pyx_PyObject_GetAttrStr_ClearAttributeError(void) { __Pyx_PyThreadState_declare __Pyx_PyThreadState_assign if (likely(__Pyx_PyErr_ExceptionMatches(PyExc_AttributeError))) __Pyx_PyErr_Clear(); } #endif static CYTHON_INLINE PyObject* __Pyx_PyObject_GetAttrStrNoError(PyObject* obj, PyObject* attr_name) { PyObject *result; #if __PYX_LIMITED_VERSION_HEX >= 0x030d00A1 (void) PyObject_GetOptionalAttr(obj, attr_name, &result); return result; #else #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; #endif } /* GetBuiltinName */ static PyObject *__Pyx_GetBuiltinName(PyObject *name) { PyObject* result = __Pyx_PyObject_GetAttrStrNoError(__pyx_b, name); if (unlikely(!result) && !PyErr_Occurred()) { 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; } /* TupleAndListFromArray */ #if CYTHON_COMPILING_IN_CPYTHON static CYTHON_INLINE void __Pyx_copy_object_array(PyObject *const *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_PyTuple_FromArray(PyObject *const *src, Py_ssize_t n) { PyObject *res; if (n <= 0) { Py_INCREF(__pyx_empty_tuple); return __pyx_empty_tuple; } res = PyTuple_New(n); if (unlikely(res == NULL)) return NULL; __Pyx_copy_object_array(src, ((PyTupleObject*)res)->ob_item, n); return res; } static CYTHON_INLINE PyObject * __Pyx_PyList_FromArray(PyObject *const *src, Py_ssize_t n) { PyObject *res; if (n <= 0) { return PyList_New(0); } res = PyList_New(n); if (unlikely(res == NULL)) return NULL; __Pyx_copy_object_array(src, ((PyListObject*)res)->ob_item, n); return res; } #endif /* BytesEquals */ static CYTHON_INLINE int __Pyx_PyBytes_Equals(PyObject* s1, PyObject* s2, int equals) { #if CYTHON_COMPILING_IN_PYPY || CYTHON_COMPILING_IN_LIMITED_API 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 || CYTHON_COMPILING_IN_LIMITED_API 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 } /* fastcall */ #if CYTHON_METH_FASTCALL static CYTHON_INLINE PyObject * __Pyx_GetKwValue_FASTCALL(PyObject *kwnames, PyObject *const *kwvalues, PyObject *s) { Py_ssize_t i, n = PyTuple_GET_SIZE(kwnames); for (i = 0; i < n; i++) { if (s == PyTuple_GET_ITEM(kwnames, i)) return kwvalues[i]; } for (i = 0; i < n; i++) { int eq = __Pyx_PyUnicode_Equals(s, PyTuple_GET_ITEM(kwnames, i), Py_EQ); if (unlikely(eq != 0)) { if (unlikely(eq < 0)) return NULL; return kwvalues[i]; } } return NULL; } #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030d0000 CYTHON_UNUSED static PyObject *__Pyx_KwargsAsDict_FASTCALL(PyObject *kwnames, PyObject *const *kwvalues) { Py_ssize_t i, nkwargs = PyTuple_GET_SIZE(kwnames); PyObject *dict; dict = PyDict_New(); if (unlikely(!dict)) return NULL; for (i=0; i= 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 *const *kwvalues, 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; int kwds_is_tuple = CYTHON_METH_FASTCALL && likely(PyTuple_Check(kwds)); while (1) { Py_XDECREF(key); key = NULL; Py_XDECREF(value); value = NULL; if (kwds_is_tuple) { Py_ssize_t size; #if CYTHON_ASSUME_SAFE_MACROS size = PyTuple_GET_SIZE(kwds); #else size = PyTuple_Size(kwds); if (size < 0) goto bad; #endif if (pos >= size) break; #if CYTHON_AVOID_BORROWED_REFS key = __Pyx_PySequence_ITEM(kwds, pos); if (!key) goto bad; #elif CYTHON_ASSUME_SAFE_MACROS key = PyTuple_GET_ITEM(kwds, pos); #else key = PyTuple_GetItem(kwds, pos); if (!key) goto bad; #endif value = kwvalues[pos]; pos++; } else { if (!PyDict_Next(kwds, &pos, &key, &value)) break; #if CYTHON_AVOID_BORROWED_REFS Py_INCREF(key); #endif } name = first_kw_arg; while (*name && (**name != key)) name++; if (*name) { values[name-argnames] = value; #if CYTHON_AVOID_BORROWED_REFS Py_INCREF(value); Py_DECREF(key); #endif key = NULL; value = NULL; continue; } #if !CYTHON_AVOID_BORROWED_REFS Py_INCREF(key); #endif Py_INCREF(value); 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; #if CYTHON_AVOID_BORROWED_REFS value = NULL; #endif 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 = ( #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; #if CYTHON_AVOID_BORROWED_REFS value = NULL; #endif 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; } } Py_XDECREF(key); Py_XDECREF(value); 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: #if PY_MAJOR_VERSION < 3 PyErr_Format(PyExc_TypeError, "%.200s() got an unexpected keyword argument '%.200s'", function_name, PyString_AsString(key)); #else PyErr_Format(PyExc_TypeError, "%s() got an unexpected keyword argument '%U'", function_name, key); #endif bad: Py_XDECREF(key); Py_XDECREF(value); return -1; } /* ArgTypeTest */ static int __Pyx__ArgTypeTest(PyObject *obj, PyTypeObject *type, const char *name, int exact) { __Pyx_TypeName type_name; __Pyx_TypeName obj_type_name; 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; } type_name = __Pyx_PyType_GetName(type); obj_type_name = __Pyx_PyType_GetName(Py_TYPE(obj)); PyErr_Format(PyExc_TypeError, "Argument '%.200s' has incorrect type (expected " __Pyx_FMT_TYPENAME ", got " __Pyx_FMT_TYPENAME ")", name, type_name, obj_type_name); __Pyx_DECREF_TypeName(type_name); __Pyx_DECREF_TypeName(obj_type_name); return 0; } /* RaiseException */ #if PY_MAJOR_VERSION < 3 static void __Pyx_Raise(PyObject *type, PyObject *value, PyObject *tb, PyObject *cause) { __Pyx_PyThreadState_declare CYTHON_UNUSED_VAR(cause); 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 PY_VERSION_HEX >= 0x030C00A6 PyException_SetTraceback(value, tb); #elif CYTHON_FAST_THREAD_STATE 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); } #else 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); #endif } bad: Py_XDECREF(owned_instance); return; } #endif /* PyFunctionFastCall */ #if CYTHON_FAST_PYCALL && !CYTHON_VECTORCALL 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; } 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_MAJOR_VERSION < 3 if (unlikely(Py_EnterRecursiveCall((char*)" while calling a Python object"))) { return NULL; } #else if (unlikely(Py_EnterRecursiveCall(" while calling a Python object"))) { return NULL; } #endif 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 /* 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 PY_MAJOR_VERSION < 3 if (unlikely(Py_EnterRecursiveCall((char*)" while calling a Python object"))) return NULL; #else if (unlikely(Py_EnterRecursiveCall(" while calling a Python object"))) return NULL; #endif 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 = __Pyx_CyOrPyCFunction_GET_FUNCTION(func); self = __Pyx_CyOrPyCFunction_GET_SELF(func); #if PY_MAJOR_VERSION < 3 if (unlikely(Py_EnterRecursiveCall((char*)" while calling a Python object"))) return NULL; #else if (unlikely(Py_EnterRecursiveCall(" while calling a Python object"))) return NULL; #endif 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 /* PyObjectFastCall */ #if PY_VERSION_HEX < 0x03090000 || CYTHON_COMPILING_IN_LIMITED_API static PyObject* __Pyx_PyObject_FastCall_fallback(PyObject *func, PyObject **args, size_t nargs, PyObject *kwargs) { PyObject *argstuple; PyObject *result = 0; size_t i; argstuple = PyTuple_New((Py_ssize_t)nargs); if (unlikely(!argstuple)) return NULL; for (i = 0; i < nargs; i++) { Py_INCREF(args[i]); if (__Pyx_PyTuple_SET_ITEM(argstuple, (Py_ssize_t)i, args[i]) < 0) goto bad; } result = __Pyx_PyObject_Call(func, argstuple, kwargs); bad: Py_DECREF(argstuple); return result; } #endif static CYTHON_INLINE PyObject* __Pyx_PyObject_FastCallDict(PyObject *func, PyObject **args, size_t _nargs, PyObject *kwargs) { Py_ssize_t nargs = __Pyx_PyVectorcall_NARGS(_nargs); #if CYTHON_COMPILING_IN_CPYTHON if (nargs == 0 && kwargs == NULL) { if (__Pyx_CyOrPyCFunction_Check(func) && likely( __Pyx_CyOrPyCFunction_GET_FLAGS(func) & METH_NOARGS)) return __Pyx_PyObject_CallMethO(func, NULL); } else if (nargs == 1 && kwargs == NULL) { if (__Pyx_CyOrPyCFunction_Check(func) && likely( __Pyx_CyOrPyCFunction_GET_FLAGS(func) & METH_O)) return __Pyx_PyObject_CallMethO(func, args[0]); } #endif #if PY_VERSION_HEX < 0x030800B1 #if CYTHON_FAST_PYCCALL if (PyCFunction_Check(func)) { if (kwargs) { return _PyCFunction_FastCallDict(func, args, nargs, kwargs); } else { return _PyCFunction_FastCallKeywords(func, args, nargs, NULL); } } #if PY_VERSION_HEX >= 0x030700A1 if (!kwargs && __Pyx_IS_TYPE(func, &PyMethodDescr_Type)) { return _PyMethodDescr_FastCallKeywords(func, args, nargs, NULL); } #endif #endif #if CYTHON_FAST_PYCALL if (PyFunction_Check(func)) { return __Pyx_PyFunction_FastCallDict(func, args, nargs, kwargs); } #endif #endif if (kwargs == NULL) { #if CYTHON_VECTORCALL #if PY_VERSION_HEX < 0x03090000 vectorcallfunc f = _PyVectorcall_Function(func); #else vectorcallfunc f = PyVectorcall_Function(func); #endif if (f) { return f(func, args, (size_t)nargs, NULL); } #elif defined(__Pyx_CyFunction_USED) && CYTHON_BACKPORT_VECTORCALL if (__Pyx_CyFunction_CheckExact(func)) { __pyx_vectorcallfunc f = __Pyx_CyFunction_func_vectorcall(func); if (f) return f(func, args, (size_t)nargs, NULL); } #endif } if (nargs == 0) { return __Pyx_PyObject_Call(func, __pyx_empty_tuple, kwargs); } #if PY_VERSION_HEX >= 0x03090000 && !CYTHON_COMPILING_IN_LIMITED_API return PyObject_VectorcallDict(func, args, (size_t)nargs, kwargs); #else return __Pyx_PyObject_FastCall_fallback(func, args, (size_t)nargs, kwargs); #endif } /* RaiseUnexpectedTypeError */ static int __Pyx_RaiseUnexpectedTypeError(const char *expected, PyObject *obj) { __Pyx_TypeName obj_type_name = __Pyx_PyType_GetName(Py_TYPE(obj)); PyErr_Format(PyExc_TypeError, "Expected %s, got " __Pyx_FMT_TYPENAME, expected, obj_type_name); __Pyx_DECREF_TypeName(obj_type_name); return 0; } /* CIntToDigits */ static const char DIGIT_PAIRS_10[2*10*10+1] = { "00010203040506070809" "10111213141516171819" "20212223242526272829" "30313233343536373839" "40414243444546474849" "50515253545556575859" "60616263646566676869" "70717273747576777879" "80818283848586878889" "90919293949596979899" }; static const char DIGIT_PAIRS_8[2*8*8+1] = { "0001020304050607" "1011121314151617" "2021222324252627" "3031323334353637" "4041424344454647" "5051525354555657" "6061626364656667" "7071727374757677" }; static const char DIGITS_HEX[2*16+1] = { "0123456789abcdef" "0123456789ABCDEF" }; /* BuildPyUnicode */ static PyObject* __Pyx_PyUnicode_BuildFromAscii(Py_ssize_t ulength, char* chars, int clength, int prepend_sign, char padding_char) { PyObject *uval; Py_ssize_t uoffset = ulength - clength; #if CYTHON_USE_UNICODE_INTERNALS Py_ssize_t i; #if CYTHON_PEP393_ENABLED void *udata; uval = PyUnicode_New(ulength, 127); if (unlikely(!uval)) return NULL; udata = PyUnicode_DATA(uval); #else Py_UNICODE *udata; uval = PyUnicode_FromUnicode(NULL, ulength); if (unlikely(!uval)) return NULL; udata = PyUnicode_AS_UNICODE(uval); #endif if (uoffset > 0) { i = 0; if (prepend_sign) { __Pyx_PyUnicode_WRITE(PyUnicode_1BYTE_KIND, udata, 0, '-'); i++; } for (; i < uoffset; i++) { __Pyx_PyUnicode_WRITE(PyUnicode_1BYTE_KIND, udata, i, padding_char); } } for (i=0; i < clength; i++) { __Pyx_PyUnicode_WRITE(PyUnicode_1BYTE_KIND, udata, uoffset+i, chars[i]); } #else { PyObject *sign = NULL, *padding = NULL; uval = NULL; if (uoffset > 0) { prepend_sign = !!prepend_sign; if (uoffset > prepend_sign) { padding = PyUnicode_FromOrdinal(padding_char); if (likely(padding) && uoffset > prepend_sign + 1) { PyObject *tmp; PyObject *repeat = PyInt_FromSsize_t(uoffset - prepend_sign); if (unlikely(!repeat)) goto done_or_error; tmp = PyNumber_Multiply(padding, repeat); Py_DECREF(repeat); Py_DECREF(padding); padding = tmp; } if (unlikely(!padding)) goto done_or_error; } if (prepend_sign) { sign = PyUnicode_FromOrdinal('-'); if (unlikely(!sign)) goto done_or_error; } } uval = PyUnicode_DecodeASCII(chars, clength, NULL); if (likely(uval) && padding) { PyObject *tmp = PyNumber_Add(padding, uval); Py_DECREF(uval); uval = tmp; } if (likely(uval) && sign) { PyObject *tmp = PyNumber_Add(sign, uval); Py_DECREF(uval); uval = tmp; } done_or_error: Py_XDECREF(padding); Py_XDECREF(sign); } #endif return uval; } /* CIntToPyUnicode */ static CYTHON_INLINE PyObject* __Pyx_PyUnicode_From_int(int value, Py_ssize_t width, char padding_char, char format_char) { char digits[sizeof(int)*3+2]; char *dpos, *end = digits + sizeof(int)*3+2; const char *hex_digits = DIGITS_HEX; Py_ssize_t length, ulength; int prepend_sign, last_one_off; int remaining; #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 (format_char == 'X') { hex_digits += 16; format_char = 'x'; } remaining = value; last_one_off = 0; dpos = end; do { int digit_pos; switch (format_char) { case 'o': digit_pos = abs((int)(remaining % (8*8))); remaining = (int) (remaining / (8*8)); dpos -= 2; memcpy(dpos, DIGIT_PAIRS_8 + digit_pos * 2, 2); last_one_off = (digit_pos < 8); break; case 'd': digit_pos = abs((int)(remaining % (10*10))); remaining = (int) (remaining / (10*10)); dpos -= 2; memcpy(dpos, DIGIT_PAIRS_10 + digit_pos * 2, 2); last_one_off = (digit_pos < 10); break; case 'x': *(--dpos) = hex_digits[abs((int)(remaining % 16))]; remaining = (int) (remaining / 16); break; default: assert(0); break; } } while (unlikely(remaining != 0)); assert(!last_one_off || *dpos == '0'); dpos += last_one_off; length = end - dpos; ulength = length; prepend_sign = 0; if (!is_unsigned && value <= neg_one) { if (padding_char == ' ' || width <= length + 1) { *(--dpos) = '-'; ++length; } else { prepend_sign = 1; } ++ulength; } if (width > ulength) { ulength = width; } if (ulength == 1) { return PyUnicode_FromOrdinal(*dpos); } return __Pyx_PyUnicode_BuildFromAscii(ulength, dpos, (int) length, prepend_sign, padding_char); } /* CIntToPyUnicode */ static CYTHON_INLINE PyObject* __Pyx_PyUnicode_From_Py_ssize_t(Py_ssize_t value, Py_ssize_t width, char padding_char, char format_char) { char digits[sizeof(Py_ssize_t)*3+2]; char *dpos, *end = digits + sizeof(Py_ssize_t)*3+2; const char *hex_digits = DIGITS_HEX; Py_ssize_t length, ulength; int prepend_sign, last_one_off; Py_ssize_t remaining; #ifdef __Pyx_HAS_GCC_DIAGNOSTIC #pragma GCC diagnostic push #pragma GCC diagnostic ignored "-Wconversion" #endif const Py_ssize_t neg_one = (Py_ssize_t) -1, const_zero = (Py_ssize_t) 0; #ifdef __Pyx_HAS_GCC_DIAGNOSTIC #pragma GCC diagnostic pop #endif const int is_unsigned = neg_one > const_zero; if (format_char == 'X') { hex_digits += 16; format_char = 'x'; } remaining = value; last_one_off = 0; dpos = end; do { int digit_pos; switch (format_char) { case 'o': digit_pos = abs((int)(remaining % (8*8))); remaining = (Py_ssize_t) (remaining / (8*8)); dpos -= 2; memcpy(dpos, DIGIT_PAIRS_8 + digit_pos * 2, 2); last_one_off = (digit_pos < 8); break; case 'd': digit_pos = abs((int)(remaining % (10*10))); remaining = (Py_ssize_t) (remaining / (10*10)); dpos -= 2; memcpy(dpos, DIGIT_PAIRS_10 + digit_pos * 2, 2); last_one_off = (digit_pos < 10); break; case 'x': *(--dpos) = hex_digits[abs((int)(remaining % 16))]; remaining = (Py_ssize_t) (remaining / 16); break; default: assert(0); break; } } while (unlikely(remaining != 0)); assert(!last_one_off || *dpos == '0'); dpos += last_one_off; length = end - dpos; ulength = length; prepend_sign = 0; if (!is_unsigned && value <= neg_one) { if (padding_char == ' ' || width <= length + 1) { *(--dpos) = '-'; ++length; } else { prepend_sign = 1; } ++ulength; } if (width > ulength) { ulength = width; } if (ulength == 1) { return PyUnicode_FromOrdinal(*dpos); } return __Pyx_PyUnicode_BuildFromAscii(ulength, dpos, (int) length, prepend_sign, padding_char); } /* JoinPyUnicode */ static PyObject* __Pyx_PyUnicode_Join(PyObject* value_tuple, Py_ssize_t value_count, Py_ssize_t result_ulength, Py_UCS4 max_char) { #if CYTHON_USE_UNICODE_INTERNALS && CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS PyObject *result_uval; int result_ukind, kind_shift; Py_ssize_t i, char_pos; void *result_udata; CYTHON_MAYBE_UNUSED_VAR(max_char); #if CYTHON_PEP393_ENABLED result_uval = PyUnicode_New(result_ulength, max_char); if (unlikely(!result_uval)) return NULL; result_ukind = (max_char <= 255) ? PyUnicode_1BYTE_KIND : (max_char <= 65535) ? PyUnicode_2BYTE_KIND : PyUnicode_4BYTE_KIND; kind_shift = (result_ukind == PyUnicode_4BYTE_KIND) ? 2 : result_ukind - 1; result_udata = PyUnicode_DATA(result_uval); #else result_uval = PyUnicode_FromUnicode(NULL, result_ulength); if (unlikely(!result_uval)) return NULL; result_ukind = sizeof(Py_UNICODE); kind_shift = (result_ukind == 4) ? 2 : result_ukind - 1; result_udata = PyUnicode_AS_UNICODE(result_uval); #endif assert(kind_shift == 2 || kind_shift == 1 || kind_shift == 0); char_pos = 0; for (i=0; i < value_count; i++) { int ukind; Py_ssize_t ulength; void *udata; PyObject *uval = PyTuple_GET_ITEM(value_tuple, i); if (unlikely(__Pyx_PyUnicode_READY(uval))) goto bad; ulength = __Pyx_PyUnicode_GET_LENGTH(uval); if (unlikely(!ulength)) continue; if (unlikely((PY_SSIZE_T_MAX >> kind_shift) - ulength < char_pos)) goto overflow; ukind = __Pyx_PyUnicode_KIND(uval); udata = __Pyx_PyUnicode_DATA(uval); if (!CYTHON_PEP393_ENABLED || ukind == result_ukind) { memcpy((char *)result_udata + (char_pos << kind_shift), udata, (size_t) (ulength << kind_shift)); } else { #if PY_VERSION_HEX >= 0x030d0000 if (unlikely(PyUnicode_CopyCharacters(result_uval, char_pos, uval, 0, ulength) < 0)) goto bad; #elif CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030300F0 || defined(_PyUnicode_FastCopyCharacters) _PyUnicode_FastCopyCharacters(result_uval, char_pos, uval, 0, ulength); #else Py_ssize_t j; for (j=0; j < ulength; j++) { Py_UCS4 uchar = __Pyx_PyUnicode_READ(ukind, udata, j); __Pyx_PyUnicode_WRITE(result_ukind, result_udata, char_pos+j, uchar); } #endif } char_pos += ulength; } return result_uval; overflow: PyErr_SetString(PyExc_OverflowError, "join() result is too long for a Python string"); bad: Py_DECREF(result_uval); return NULL; #else CYTHON_UNUSED_VAR(max_char); CYTHON_UNUSED_VAR(result_ulength); CYTHON_UNUSED_VAR(value_count); return PyUnicode_Join(__pyx_empty_unicode, value_tuple); #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); } /* GetItemInt */ static PyObject *__Pyx_GetItemInt_Generic(PyObject *o, PyObject* j) { PyObject *r; if (unlikely(!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 { PyMappingMethods *mm = Py_TYPE(o)->tp_as_mapping; PySequenceMethods *sm = Py_TYPE(o)->tp_as_sequence; if (mm && mm->mp_subscript) { PyObject *r, *key = PyInt_FromSsize_t(i); if (unlikely(!key)) return NULL; r = mm->mp_subscript(o, key); Py_DECREF(key); return r; } if (likely(sm && sm->sq_item)) { if (wraparound && unlikely(i < 0) && likely(sm->sq_length)) { Py_ssize_t l = sm->sq_length(o); if (likely(l >= 0)) { i += l; } else { if (!PyErr_ExceptionMatches(PyExc_OverflowError)) return NULL; PyErr_Clear(); } } return sm->sq_item(o, i); } } #else if (is_list || !PyMapping_Check(o)) { return PySequence_GetItem(o, i); } #endif return __Pyx_GetItemInt_Generic(o, PyInt_FromSsize_t(i)); } /* PyObjectCallOneArg */ static CYTHON_INLINE PyObject* __Pyx_PyObject_CallOneArg(PyObject *func, PyObject *arg) { PyObject *args[2] = {NULL, arg}; return __Pyx_PyObject_FastCall(func, args+1, 1 | __Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET); } /* ObjectGetItem */ #if CYTHON_USE_TYPE_SLOTS static PyObject *__Pyx_PyObject_GetIndex(PyObject *obj, PyObject *index) { PyObject *runerr = NULL; Py_ssize_t key_value; 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)) { __Pyx_TypeName index_type_name = __Pyx_PyType_GetName(Py_TYPE(index)); PyErr_Clear(); PyErr_Format(PyExc_IndexError, "cannot fit '" __Pyx_FMT_TYPENAME "' into an index-sized integer", index_type_name); __Pyx_DECREF_TypeName(index_type_name); } return NULL; } static PyObject *__Pyx_PyObject_GetItem_Slow(PyObject *obj, PyObject *key) { __Pyx_TypeName obj_type_name; if (likely(PyType_Check(obj))) { PyObject *meth = __Pyx_PyObject_GetAttrStrNoError(obj, __pyx_n_s_class_getitem); if (!meth) { PyErr_Clear(); } else { PyObject *result = __Pyx_PyObject_CallOneArg(meth, key); Py_DECREF(meth); return result; } } obj_type_name = __Pyx_PyType_GetName(Py_TYPE(obj)); PyErr_Format(PyExc_TypeError, "'" __Pyx_FMT_TYPENAME "' object is not subscriptable", obj_type_name); __Pyx_DECREF_TypeName(obj_type_name); return NULL; } static PyObject *__Pyx_PyObject_GetItem(PyObject *obj, PyObject *key) { PyTypeObject *tp = Py_TYPE(obj); PyMappingMethods *mm = tp->tp_as_mapping; PySequenceMethods *sm = tp->tp_as_sequence; if (likely(mm && mm->mp_subscript)) { return mm->mp_subscript(obj, key); } if (likely(sm && sm->sq_item)) { return __Pyx_PyObject_GetIndex(obj, key); } return __Pyx_PyObject_GetItem_Slow(obj, key); } #endif /* KeywordStringCheck */ static int __Pyx_CheckKeywordStrings( PyObject *kw, 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(kw, &pos, &key, 0)) goto invalid_keyword; return 1; #else if (CYTHON_METH_FASTCALL && likely(PyTuple_Check(kw))) { Py_ssize_t kwsize; #if CYTHON_ASSUME_SAFE_MACROS kwsize = PyTuple_GET_SIZE(kw); #else kwsize = PyTuple_Size(kw); if (kwsize < 0) return 0; #endif if (unlikely(kwsize == 0)) return 1; if (!kw_allowed) { #if CYTHON_ASSUME_SAFE_MACROS key = PyTuple_GET_ITEM(kw, 0); #else key = PyTuple_GetItem(kw, pos); if (!key) return 0; #endif goto invalid_keyword; } #if PY_VERSION_HEX < 0x03090000 for (pos = 0; pos < kwsize; pos++) { #if CYTHON_ASSUME_SAFE_MACROS key = PyTuple_GET_ITEM(kw, pos); #else key = PyTuple_GetItem(kw, pos); if (!key) return 0; #endif if (unlikely(!PyUnicode_Check(key))) goto invalid_keyword_type; } #endif return 1; } while (PyDict_Next(kw, &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: #if PY_MAJOR_VERSION < 3 PyErr_Format(PyExc_TypeError, "%.200s() got an unexpected keyword argument '%.200s'", function_name, PyString_AsString(key)); #else PyErr_Format(PyExc_TypeError, "%s() got an unexpected keyword argument '%U'", function_name, key); #endif return 0; } /* 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; } /* GetAttr3 */ #if __PYX_LIMITED_VERSION_HEX < 0x030d00A1 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; } #endif static CYTHON_INLINE PyObject *__Pyx_GetAttr3(PyObject *o, PyObject *n, PyObject *d) { PyObject *r; #if __PYX_LIMITED_VERSION_HEX >= 0x030d00A1 int res = PyObject_GetOptionalAttr(o, n, &r); return (res != 0) ? r : __Pyx_NewRef(d); #else #if CYTHON_USE_TYPE_SLOTS if (likely(PyString_Check(n))) { r = __Pyx_PyObject_GetAttrStrNoError(o, n); if (unlikely(!r) && likely(!PyErr_Occurred())) { r = __Pyx_NewRef(d); } return r; } #endif r = PyObject_GetAttr(o, n); return (likely(r)) ? r : __Pyx_GetAttr3Default(d); #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 && PY_VERSION_HEX < 0x030d0000 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; } #elif CYTHON_COMPILING_IN_LIMITED_API if (unlikely(!__pyx_m)) { return NULL; } result = PyObject_GetAttr(__pyx_m, name); if (likely(result)) { return result; } #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); } /* 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"); } /* RaiseNoneIterError */ static CYTHON_INLINE void __Pyx_RaiseNoneNotIterableError(void) { PyErr_SetString(PyExc_TypeError, "'NoneType' object is not iterable"); } /* ExtTypeTest */ static CYTHON_INLINE int __Pyx_TypeTest(PyObject *obj, PyTypeObject *type) { __Pyx_TypeName obj_type_name; __Pyx_TypeName type_name; if (unlikely(!type)) { PyErr_SetString(PyExc_SystemError, "Missing type object"); return 0; } if (likely(__Pyx_TypeCheck(obj, type))) return 1; obj_type_name = __Pyx_PyType_GetName(Py_TYPE(obj)); type_name = __Pyx_PyType_GetName(type); PyErr_Format(PyExc_TypeError, "Cannot convert " __Pyx_FMT_TYPENAME " to " __Pyx_FMT_TYPENAME, obj_type_name, type_name); __Pyx_DECREF_TypeName(obj_type_name); __Pyx_DECREF_TypeName(type_name); return 0; } /* GetTopmostException */ #if CYTHON_USE_EXC_INFO_STACK && CYTHON_FAST_THREAD_STATE static _PyErr_StackItem * __Pyx_PyErr_GetTopmostException(PyThreadState *tstate) { _PyErr_StackItem *exc_info = tstate->exc_info; while ((exc_info->exc_value == NULL || exc_info->exc_value == 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 && PY_VERSION_HEX >= 0x030B00a4 _PyErr_StackItem *exc_info = __Pyx_PyErr_GetTopmostException(tstate); PyObject *exc_value = exc_info->exc_value; if (exc_value == NULL || exc_value == Py_None) { *value = NULL; *type = NULL; *tb = NULL; } else { *value = exc_value; Py_INCREF(*value); *type = (PyObject*) Py_TYPE(exc_value); Py_INCREF(*type); *tb = PyException_GetTraceback(exc_value); } #elif 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; Py_XINCREF(*type); Py_XINCREF(*value); Py_XINCREF(*tb); #else *type = tstate->exc_type; *value = tstate->exc_value; *tb = tstate->exc_traceback; Py_XINCREF(*type); Py_XINCREF(*value); Py_XINCREF(*tb); #endif } static CYTHON_INLINE void __Pyx__ExceptionReset(PyThreadState *tstate, PyObject *type, PyObject *value, PyObject *tb) { #if CYTHON_USE_EXC_INFO_STACK && PY_VERSION_HEX >= 0x030B00a4 _PyErr_StackItem *exc_info = tstate->exc_info; PyObject *tmp_value = exc_info->exc_value; exc_info->exc_value = value; Py_XDECREF(tmp_value); Py_XDECREF(type); Py_XDECREF(tb); #else 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 } #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 = NULL, *local_value, *local_tb = NULL; #if CYTHON_FAST_THREAD_STATE PyObject *tmp_type, *tmp_value, *tmp_tb; #if PY_VERSION_HEX >= 0x030C00A6 local_value = tstate->current_exception; tstate->current_exception = 0; if (likely(local_value)) { local_type = (PyObject*) Py_TYPE(local_value); Py_INCREF(local_type); local_tb = PyException_GetTraceback(local_value); } #else 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; #endif #else PyErr_Fetch(&local_type, &local_value, &local_tb); #endif PyErr_NormalizeException(&local_type, &local_value, &local_tb); #if CYTHON_FAST_THREAD_STATE && PY_VERSION_HEX >= 0x030C00A6 if (unlikely(tstate->current_exception)) #elif 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; #if PY_VERSION_HEX >= 0x030B00a4 tmp_value = exc_info->exc_value; exc_info->exc_value = local_value; tmp_type = NULL; tmp_tb = NULL; Py_XDECREF(local_type); Py_XDECREF(local_tb); #else 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; #endif } #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 && PY_VERSION_HEX >= 0x030B00a4 _PyErr_StackItem *exc_info = tstate->exc_info; tmp_value = exc_info->exc_value; exc_info->exc_value = *value; if (tmp_value == NULL || tmp_value == Py_None) { Py_XDECREF(tmp_value); tmp_value = NULL; tmp_type = NULL; tmp_tb = NULL; } else { tmp_type = (PyObject*) Py_TYPE(tmp_value); Py_INCREF(tmp_type); #if CYTHON_COMPILING_IN_CPYTHON tmp_tb = ((PyBaseExceptionObject*) tmp_value)->traceback; Py_XINCREF(tmp_tb); #else tmp_tb = PyException_GetTraceback(tmp_value); #endif } #elif 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 *module = 0; PyObject *empty_dict = 0; PyObject *empty_list = 0; #if PY_MAJOR_VERSION < 3 PyObject *py_import; py_import = __Pyx_PyObject_GetAttrStr(__pyx_b, __pyx_n_s_import); if (unlikely(!py_import)) goto bad; if (!from_list) { empty_list = PyList_New(0); if (unlikely(!empty_list)) goto bad; from_list = empty_list; } #endif empty_dict = PyDict_New(); if (unlikely(!empty_dict)) goto bad; { #if PY_MAJOR_VERSION >= 3 if (level == -1) { if (strchr(__Pyx_MODULE_NAME, '.') != NULL) { module = PyImport_ImportModuleLevelObject( name, __pyx_d, empty_dict, from_list, 1); if (unlikely(!module)) { if (unlikely(!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 (unlikely(!py_level)) goto bad; module = PyObject_CallFunctionObjArgs(py_import, name, __pyx_d, empty_dict, from_list, py_level, (PyObject *)NULL); Py_DECREF(py_level); #else module = PyImport_ImportModuleLevelObject( name, __pyx_d, empty_dict, from_list, level); #endif } } bad: Py_XDECREF(empty_dict); Py_XDECREF(empty_list); #if PY_MAJOR_VERSION < 3 Py_XDECREF(py_import); #endif return module; } /* ImportDottedModule */ #if PY_MAJOR_VERSION >= 3 static PyObject *__Pyx__ImportDottedModule_Error(PyObject *name, PyObject *parts_tuple, Py_ssize_t count) { PyObject *partial_name = NULL, *slice = NULL, *sep = NULL; if (unlikely(PyErr_Occurred())) { PyErr_Clear(); } if (likely(PyTuple_GET_SIZE(parts_tuple) == count)) { partial_name = name; } else { slice = PySequence_GetSlice(parts_tuple, 0, count); if (unlikely(!slice)) goto bad; sep = PyUnicode_FromStringAndSize(".", 1); if (unlikely(!sep)) goto bad; partial_name = PyUnicode_Join(sep, slice); } PyErr_Format( #if PY_MAJOR_VERSION < 3 PyExc_ImportError, "No module named '%s'", PyString_AS_STRING(partial_name)); #else #if PY_VERSION_HEX >= 0x030600B1 PyExc_ModuleNotFoundError, #else PyExc_ImportError, #endif "No module named '%U'", partial_name); #endif bad: Py_XDECREF(sep); Py_XDECREF(slice); Py_XDECREF(partial_name); return NULL; } #endif #if PY_MAJOR_VERSION >= 3 static PyObject *__Pyx__ImportDottedModule_Lookup(PyObject *name) { PyObject *imported_module; #if PY_VERSION_HEX < 0x030700A1 || (CYTHON_COMPILING_IN_PYPY && PYPY_VERSION_NUM < 0x07030400) PyObject *modules = PyImport_GetModuleDict(); if (unlikely(!modules)) return NULL; imported_module = __Pyx_PyDict_GetItemStr(modules, name); Py_XINCREF(imported_module); #else imported_module = PyImport_GetModule(name); #endif return imported_module; } #endif #if PY_MAJOR_VERSION >= 3 static PyObject *__Pyx_ImportDottedModule_WalkParts(PyObject *module, PyObject *name, PyObject *parts_tuple) { Py_ssize_t i, nparts; nparts = PyTuple_GET_SIZE(parts_tuple); for (i=1; i < nparts && module; i++) { PyObject *part, *submodule; #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS part = PyTuple_GET_ITEM(parts_tuple, i); #else part = PySequence_ITEM(parts_tuple, i); #endif submodule = __Pyx_PyObject_GetAttrStrNoError(module, part); #if !(CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS) Py_DECREF(part); #endif Py_DECREF(module); module = submodule; } if (unlikely(!module)) { return __Pyx__ImportDottedModule_Error(name, parts_tuple, i); } return module; } #endif static PyObject *__Pyx__ImportDottedModule(PyObject *name, PyObject *parts_tuple) { #if PY_MAJOR_VERSION < 3 PyObject *module, *from_list, *star = __pyx_n_s__3; CYTHON_UNUSED_VAR(parts_tuple); from_list = PyList_New(1); if (unlikely(!from_list)) return NULL; Py_INCREF(star); PyList_SET_ITEM(from_list, 0, star); module = __Pyx_Import(name, from_list, 0); Py_DECREF(from_list); return module; #else PyObject *imported_module; PyObject *module = __Pyx_Import(name, NULL, 0); if (!parts_tuple || unlikely(!module)) return module; imported_module = __Pyx__ImportDottedModule_Lookup(name); if (likely(imported_module)) { Py_DECREF(module); return imported_module; } PyErr_Clear(); return __Pyx_ImportDottedModule_WalkParts(module, name, parts_tuple); #endif } static PyObject *__Pyx_ImportDottedModule(PyObject *name, PyObject *parts_tuple) { #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030400B1 PyObject *module = __Pyx__ImportDottedModule_Lookup(name); if (likely(module)) { PyObject *spec = __Pyx_PyObject_GetAttrStrNoError(module, __pyx_n_s_spec); if (likely(spec)) { PyObject *unsafe = __Pyx_PyObject_GetAttrStrNoError(spec, __pyx_n_s_initializing); if (likely(!unsafe || !__Pyx_PyObject_IsTrue(unsafe))) { Py_DECREF(spec); spec = NULL; } Py_XDECREF(unsafe); } if (likely(!spec)) { PyErr_Clear(); return module; } Py_DECREF(spec); Py_DECREF(module); } else if (PyErr_Occurred()) { PyErr_Clear(); } #endif return __Pyx__ImportDottedModule(name, parts_tuple); } /* FastTypeChecks */ #if CYTHON_COMPILING_IN_CPYTHON static int __Pyx_InBases(PyTypeObject *a, PyTypeObject *b) { while (a) { a = __Pyx_PyType_GetSlot(a, tp_base, PyTypeObject*); 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); } static CYTHON_INLINE int __Pyx_IsAnySubtype2(PyTypeObject *cls, PyTypeObject *a, PyTypeObject *b) { PyObject *mro; if (cls == a || cls == b) return 1; mro = cls->tp_mro; if (likely(mro)) { Py_ssize_t i, n; n = PyTuple_GET_SIZE(mro); for (i = 0; i < n; i++) { PyObject *base = PyTuple_GET_ITEM(mro, i); if (base == (PyObject *)a || base == (PyObject *)b) return 1; } return 0; } return __Pyx_InBases(cls, a) || __Pyx_InBases(cls, 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) { if (exc_type1) { return __Pyx_IsAnySubtype2((PyTypeObject*)err, (PyTypeObject*)exc_type1, (PyTypeObject*)exc_type2); } else { return __Pyx_IsSubtype((PyTypeObject*)err, (PyTypeObject*)exc_type2); } } #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; itp_as_sequence && type->tp_as_sequence->sq_repeat)) { return type->tp_as_sequence->sq_repeat(seq, mul); } else #endif { return __Pyx_PySequence_Multiply_Generic(seq, mul); } } /* SetItemInt */ static int __Pyx_SetItemInt_Generic(PyObject *o, PyObject *j, PyObject *v) { int r; if (unlikely(!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 { PyMappingMethods *mm = Py_TYPE(o)->tp_as_mapping; PySequenceMethods *sm = Py_TYPE(o)->tp_as_sequence; if (mm && mm->mp_ass_subscript) { int r; PyObject *key = PyInt_FromSsize_t(i); if (unlikely(!key)) return -1; r = mm->mp_ass_subscript(o, key, v); Py_DECREF(key); return r; } if (likely(sm && sm->sq_ass_item)) { if (wraparound && unlikely(i < 0) && likely(sm->sq_length)) { Py_ssize_t l = sm->sq_length(o); if (likely(l >= 0)) { i += l; } else { if (!PyErr_ExceptionMatches(PyExc_OverflowError)) return -1; PyErr_Clear(); } } return sm->sq_ass_item(o, i, v); } } #else if (is_list || !PyMapping_Check(o)) { return PySequence_SetItem(o, i, v); } #endif return __Pyx_SetItemInt_Generic(o, PyInt_FromSsize_t(i), v); } /* RaiseUnboundLocalError */ 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)) { const char* module_name_str = 0; PyObject* module_name = 0; PyObject* module_dot = 0; PyObject* full_name = 0; PyErr_Clear(); module_name_str = PyModule_GetName(module); if (unlikely(!module_name_str)) { goto modbad; } module_name = PyUnicode_FromString(module_name_str); if (unlikely(!module_name)) { goto modbad; } module_dot = PyUnicode_Concat(module_name, __pyx_kp_u__2); if (unlikely(!module_dot)) { goto modbad; } full_name = PyUnicode_Concat(module_dot, name); if (unlikely(!full_name)) { goto modbad; } #if PY_VERSION_HEX < 0x030700A1 || (CYTHON_COMPILING_IN_PYPY && PYPY_VERSION_NUM < 0x07030400) { PyObject *modules = PyImport_GetModuleDict(); if (unlikely(!modules)) goto modbad; value = PyObject_GetItem(modules, full_name); } #else value = PyImport_GetModule(full_name); #endif modbad: Py_XDECREF(full_name); Py_XDECREF(module_dot); Py_XDECREF(module_name); } if (unlikely(!value)) { 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 */ #if __PYX_LIMITED_VERSION_HEX < 0x030d00A1 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 (!r) { PyErr_Clear(); return 0; } else { Py_DECREF(r); return 1; } } #endif /* SliceObject */ static CYTHON_INLINE int __Pyx_PyObject_SetSlice(PyObject* obj, PyObject* value, 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) { __Pyx_TypeName obj_type_name; #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_ass_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_ass_slice(obj, cstart, cstop, value); } #else CYTHON_UNUSED_VAR(wraparound); #endif mp = Py_TYPE(obj)->tp_as_mapping; if (likely(mp && mp->mp_ass_subscript)) #else CYTHON_UNUSED_VAR(wraparound); #endif { int 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_ass_subscript(obj, py_slice, value); #else result = value ? PyObject_SetItem(obj, py_slice, value) : PyObject_DelItem(obj, py_slice); #endif if (!_py_slice) { Py_DECREF(py_slice); } return result; } obj_type_name = __Pyx_PyType_GetName(Py_TYPE(obj)); PyErr_Format(PyExc_TypeError, "'" __Pyx_FMT_TYPENAME "' object does not support slice %.10s", obj_type_name, value ? "assignment" : "deletion"); __Pyx_DECREF_TypeName(obj_type_name); bad: return -1; } /* PyFloatBinop */ #if !CYTHON_COMPILING_IN_PYPY static PyObject* __Pyx_PyFloat_TrueDivideCObj(PyObject *op1, PyObject *op2, double floatval, int inplace, int zerodivision_check) { const double a = floatval; double b, result; CYTHON_UNUSED_VAR(inplace); CYTHON_UNUSED_VAR(zerodivision_check); if (likely(PyFloat_CheckExact(op2))) { #if CYTHON_COMPILING_IN_LIMITED_API b = __pyx_PyFloat_AsDouble(op2); #else b = PyFloat_AS_DOUBLE(op2); #endif if (unlikely(zerodivision_check && ((b) == 0.0))) { PyErr_SetString(PyExc_ZeroDivisionError, "float division by zero"); return NULL;} } else #if PY_MAJOR_VERSION < 3 if (likely(PyInt_CheckExact(op2))) { b = (double) PyInt_AS_LONG(op2); if (unlikely(zerodivision_check && ((b) == 0.0))) { PyErr_SetString(PyExc_ZeroDivisionError, "float division by zero"); return NULL;} } else #endif if (likely(PyLong_CheckExact(op2))) { #if CYTHON_USE_PYLONG_INTERNALS if (__Pyx_PyLong_IsZero(op2)) { b = 0.0; if (unlikely(zerodivision_check && ((b) == 0.0))) { PyErr_SetString(PyExc_ZeroDivisionError, "float division by zero"); return NULL;} } else if (__Pyx_PyLong_IsCompact(op2)) { b = (double) __Pyx_PyLong_CompactValue(op2); } else { const digit* digits = __Pyx_PyLong_Digits(op2); const Py_ssize_t size = __Pyx_PyLong_SignedDigitCount(op2); switch (size) { case -2: case 2: if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT && ((8 * sizeof(unsigned long) < 53) || (1 * PyLong_SHIFT < 53))) { b = (double) (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])); if ((8 * sizeof(unsigned long) < 53) || (2 * PyLong_SHIFT < 53) || (b < (double) ((PY_LONG_LONG)1 << 53))) { if (size == -2) b = -b; break; } } CYTHON_FALLTHROUGH; case -3: case 3: if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT && ((8 * sizeof(unsigned long) < 53) || (2 * PyLong_SHIFT < 53))) { b = (double) (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])); if ((8 * sizeof(unsigned long) < 53) || (3 * PyLong_SHIFT < 53) || (b < (double) ((PY_LONG_LONG)1 << 53))) { if (size == -3) b = -b; break; } } CYTHON_FALLTHROUGH; case -4: case 4: if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT && ((8 * sizeof(unsigned long) < 53) || (3 * PyLong_SHIFT < 53))) { b = (double) (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])); if ((8 * sizeof(unsigned long) < 53) || (4 * PyLong_SHIFT < 53) || (b < (double) ((PY_LONG_LONG)1 << 53))) { if (size == -4) b = -b; break; } } CYTHON_FALLTHROUGH; default: #endif b = PyLong_AsDouble(op2); if (unlikely(b == -1.0 && PyErr_Occurred())) return NULL; #if !CYTHON_USE_PYLONG_INTERNALS if (unlikely(zerodivision_check && ((b) == 0.0))) { PyErr_SetString(PyExc_ZeroDivisionError, "float division by zero"); return NULL;} #endif #if CYTHON_USE_PYLONG_INTERNALS } } #endif } else { return (inplace ? PyNumber_InPlaceTrueDivide : PyNumber_TrueDivide)(op1, op2); } PyFPE_START_PROTECT("divide", return NULL) result = a / b; PyFPE_END_PROTECT(result) return PyFloat_FromDouble(result); } #endif /* PyIntCompare */ static CYTHON_INLINE int __Pyx_PyInt_BoolEqObjC(PyObject *op1, PyObject *op2, long intval, long inplace) { CYTHON_MAYBE_UNUSED_VAR(intval); CYTHON_UNUSED_VAR(inplace); if (op1 == op2) { return 1; } #if PY_MAJOR_VERSION < 3 if (likely(PyInt_CheckExact(op1))) { const long b = intval; long a = PyInt_AS_LONG(op1); return (a == b); } #endif #if CYTHON_USE_PYLONG_INTERNALS if (likely(PyLong_CheckExact(op1))) { int unequal; unsigned long uintval; Py_ssize_t size = __Pyx_PyLong_DigitCount(op1); const digit* digits = __Pyx_PyLong_Digits(op1); if (intval == 0) { return (__Pyx_PyLong_IsZero(op1) == 1); } else if (intval < 0) { if (__Pyx_PyLong_IsNonNeg(op1)) return 0; intval = -intval; } else { if (__Pyx_PyLong_IsNeg(op1)) return 0; } 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)); return (unequal == 0); } #endif if (PyFloat_CheckExact(op1)) { const long b = intval; #if CYTHON_COMPILING_IN_LIMITED_API double a = __pyx_PyFloat_AsDouble(op1); #else double a = PyFloat_AS_DOUBLE(op1); #endif return ((double)a == (double)b); } return __Pyx_PyObject_IsTrueAndDecref( PyObject_RichCompare(op1, op2, Py_EQ)); } /* 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 "unparsable 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, int is_complex) { CYTHON_UNUSED_VAR(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, int is_complex) { CYTHON_UNUSED_VAR(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 int __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 -1; } if (__Pyx_BufFmt_ProcessTypeChunk(ctx) == -1) return -1; 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 -1; if (i < ndim && (size_t) number != ctx->head->field->type->arraysize[i]) { PyErr_Format(PyExc_ValueError, "Expected a dimension of size %zu, got %d", ctx->head->field->type->arraysize[i], number); return -1; } if (*ts != ',' && *ts != ')') { PyErr_Format(PyExc_ValueError, "Expected a comma in format string, got '%c'", *ts); return -1; } if (*ts == ',') ts++; i++; } if (i != ndim) { PyErr_Format(PyExc_ValueError, "Expected %d dimension(s), got %d", ctx->head->field->type->ndim, i); return -1; } if (!*ts) { PyErr_SetString(PyExc_ValueError, "Unexpected end of format string, expected ')'"); return -1; } ctx->is_valid_array = 1; ctx->new_count = 1; *tsp = ++ts; return 0; } 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) < 0) 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; } /* PyFloatBinop */ #if !CYTHON_COMPILING_IN_PYPY static PyObject* __Pyx_PyFloat_SubtractObjC(PyObject *op1, PyObject *op2, double floatval, int inplace, int zerodivision_check) { const double b = floatval; double a, result; CYTHON_UNUSED_VAR(inplace); CYTHON_UNUSED_VAR(zerodivision_check); if (likely(PyFloat_CheckExact(op1))) { #if CYTHON_COMPILING_IN_LIMITED_API a = __pyx_PyFloat_AsDouble(op1); #else a = PyFloat_AS_DOUBLE(op1); #endif } else #if PY_MAJOR_VERSION < 3 if (likely(PyInt_CheckExact(op1))) { a = (double) PyInt_AS_LONG(op1); } else #endif if (likely(PyLong_CheckExact(op1))) { #if CYTHON_USE_PYLONG_INTERNALS if (__Pyx_PyLong_IsZero(op1)) { a = 0.0; } else if (__Pyx_PyLong_IsCompact(op1)) { a = (double) __Pyx_PyLong_CompactValue(op1); } else { const digit* digits = __Pyx_PyLong_Digits(op1); const Py_ssize_t size = __Pyx_PyLong_SignedDigitCount(op1); switch (size) { case -2: case 2: if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT && ((8 * sizeof(unsigned long) < 53) || (1 * PyLong_SHIFT < 53))) { a = (double) (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])); if ((8 * sizeof(unsigned long) < 53) || (2 * PyLong_SHIFT < 53) || (a < (double) ((PY_LONG_LONG)1 << 53))) { if (size == -2) a = -a; break; } } CYTHON_FALLTHROUGH; case -3: case 3: if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT && ((8 * sizeof(unsigned long) < 53) || (2 * PyLong_SHIFT < 53))) { a = (double) (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])); if ((8 * sizeof(unsigned long) < 53) || (3 * PyLong_SHIFT < 53) || (a < (double) ((PY_LONG_LONG)1 << 53))) { if (size == -3) a = -a; break; } } CYTHON_FALLTHROUGH; case -4: case 4: if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT && ((8 * sizeof(unsigned long) < 53) || (3 * PyLong_SHIFT < 53))) { a = (double) (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])); if ((8 * sizeof(unsigned long) < 53) || (4 * PyLong_SHIFT < 53) || (a < (double) ((PY_LONG_LONG)1 << 53))) { if (size == -4) a = -a; break; } } CYTHON_FALLTHROUGH; default: #endif a = PyLong_AsDouble(op1); if (unlikely(a == -1.0 && PyErr_Occurred())) return NULL; #if CYTHON_USE_PYLONG_INTERNALS } } #endif } else { return (inplace ? PyNumber_InPlaceSubtract : PyNumber_Subtract)(op1, op2); } PyFPE_START_PROTECT("subtract", return NULL) result = a - b; PyFPE_END_PROTECT(result) return PyFloat_FromDouble(result); } #endif /* PyFloatBinop */ #if !CYTHON_COMPILING_IN_PYPY static PyObject* __Pyx_PyFloat_AddCObj(PyObject *op1, PyObject *op2, double floatval, int inplace, int zerodivision_check) { const double a = floatval; double b, result; CYTHON_UNUSED_VAR(inplace); CYTHON_UNUSED_VAR(zerodivision_check); if (likely(PyFloat_CheckExact(op2))) { #if CYTHON_COMPILING_IN_LIMITED_API b = __pyx_PyFloat_AsDouble(op2); #else b = PyFloat_AS_DOUBLE(op2); #endif } else #if PY_MAJOR_VERSION < 3 if (likely(PyInt_CheckExact(op2))) { b = (double) PyInt_AS_LONG(op2); } else #endif if (likely(PyLong_CheckExact(op2))) { #if CYTHON_USE_PYLONG_INTERNALS if (__Pyx_PyLong_IsZero(op2)) { b = 0.0; } else if (__Pyx_PyLong_IsCompact(op2)) { b = (double) __Pyx_PyLong_CompactValue(op2); } else { const digit* digits = __Pyx_PyLong_Digits(op2); const Py_ssize_t size = __Pyx_PyLong_SignedDigitCount(op2); switch (size) { case -2: case 2: if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT && ((8 * sizeof(unsigned long) < 53) || (1 * PyLong_SHIFT < 53))) { b = (double) (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])); if ((8 * sizeof(unsigned long) < 53) || (2 * PyLong_SHIFT < 53) || (b < (double) ((PY_LONG_LONG)1 << 53))) { if (size == -2) b = -b; break; } } CYTHON_FALLTHROUGH; case -3: case 3: if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT && ((8 * sizeof(unsigned long) < 53) || (2 * PyLong_SHIFT < 53))) { b = (double) (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])); if ((8 * sizeof(unsigned long) < 53) || (3 * PyLong_SHIFT < 53) || (b < (double) ((PY_LONG_LONG)1 << 53))) { if (size == -3) b = -b; break; } } CYTHON_FALLTHROUGH; case -4: case 4: if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT && ((8 * sizeof(unsigned long) < 53) || (3 * PyLong_SHIFT < 53))) { b = (double) (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])); if ((8 * sizeof(unsigned long) < 53) || (4 * PyLong_SHIFT < 53) || (b < (double) ((PY_LONG_LONG)1 << 53))) { if (size == -4) b = -b; break; } } CYTHON_FALLTHROUGH; default: #endif b = PyLong_AsDouble(op2); if (unlikely(b == -1.0 && PyErr_Occurred())) return NULL; #if CYTHON_USE_PYLONG_INTERNALS } } #endif } else { return (inplace ? PyNumber_InPlaceAdd : PyNumber_Add)(op1, op2); } PyFPE_START_PROTECT("add", return NULL) result = a + b; PyFPE_END_PROTECT(result) return PyFloat_FromDouble(result); } #endif /* PyObject_GenericGetAttrNoDict */ #if CYTHON_USE_TYPE_SLOTS && CYTHON_USE_PYTYPE_LOOKUP && PY_VERSION_HEX < 0x03070000 static PyObject *__Pyx_RaiseGenericGetAttributeError(PyTypeObject *tp, PyObject *attr_name) { __Pyx_TypeName type_name = __Pyx_PyType_GetName(tp); PyErr_Format(PyExc_AttributeError, #if PY_MAJOR_VERSION >= 3 "'" __Pyx_FMT_TYPENAME "' object has no attribute '%U'", type_name, attr_name); #else "'" __Pyx_FMT_TYPENAME "' object has no attribute '%.400s'", type_name, PyString_AS_STRING(attr_name)); #endif __Pyx_DECREF_TypeName(type_name); 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 /* FixUpExtensionType */ #if CYTHON_USE_TYPE_SPECS static int __Pyx_fix_up_extension_type_from_spec(PyType_Spec *spec, PyTypeObject *type) { #if PY_VERSION_HEX > 0x030900B1 || CYTHON_COMPILING_IN_LIMITED_API CYTHON_UNUSED_VAR(spec); CYTHON_UNUSED_VAR(type); #else const PyType_Slot *slot = spec->slots; while (slot && slot->slot && slot->slot != Py_tp_members) slot++; if (slot && slot->slot == Py_tp_members) { int changed = 0; #if !(PY_VERSION_HEX <= 0x030900b1 && CYTHON_COMPILING_IN_CPYTHON) const #endif PyMemberDef *memb = (PyMemberDef*) slot->pfunc; while (memb && memb->name) { if (memb->name[0] == '_' && memb->name[1] == '_') { #if PY_VERSION_HEX < 0x030900b1 if (strcmp(memb->name, "__weaklistoffset__") == 0) { assert(memb->type == T_PYSSIZET); assert(memb->flags == READONLY); type->tp_weaklistoffset = memb->offset; changed = 1; } else if (strcmp(memb->name, "__dictoffset__") == 0) { assert(memb->type == T_PYSSIZET); assert(memb->flags == READONLY); type->tp_dictoffset = memb->offset; changed = 1; } #if CYTHON_METH_FASTCALL else if (strcmp(memb->name, "__vectorcalloffset__") == 0) { assert(memb->type == T_PYSSIZET); assert(memb->flags == READONLY); #if PY_VERSION_HEX >= 0x030800b4 type->tp_vectorcall_offset = memb->offset; #else type->tp_print = (printfunc) memb->offset; #endif changed = 1; } #endif #else if ((0)); #endif #if PY_VERSION_HEX <= 0x030900b1 && CYTHON_COMPILING_IN_CPYTHON else if (strcmp(memb->name, "__module__") == 0) { PyObject *descr; assert(memb->type == T_OBJECT); assert(memb->flags == 0 || memb->flags == READONLY); descr = PyDescr_NewMember(type, memb); if (unlikely(!descr)) return -1; if (unlikely(PyDict_SetItem(type->tp_dict, PyDescr_NAME(descr), descr) < 0)) { Py_DECREF(descr); return -1; } Py_DECREF(descr); changed = 1; } #endif } memb++; } if (changed) PyType_Modified(type); } #endif return 0; } #endif /* PyObjectCallNoArg */ static CYTHON_INLINE PyObject* __Pyx_PyObject_CallNoArg(PyObject *func) { PyObject *arg[2] = {NULL, NULL}; return __Pyx_PyObject_FastCall(func, arg + 1, 0 | __Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET); } /* 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 __Pyx_TypeName type_name; 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 defined(Py_TPFLAGS_METHOD_DESCRIPTOR) && Py_TPFLAGS_METHOD_DESCRIPTOR if (__Pyx_PyType_HasFeature(Py_TYPE(descr), Py_TPFLAGS_METHOD_DESCRIPTOR)) #elif PY_MAJOR_VERSION >= 3 #ifdef __Pyx_CyFunction_USED if (likely(PyFunction_Check(descr) || __Pyx_IS_TYPE(descr, &PyMethodDescr_Type) || __Pyx_CyFunction_Check(descr))) #else if (likely(PyFunction_Check(descr) || __Pyx_IS_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 (likely(descr != NULL)) { *method = descr; return 0; } type_name = __Pyx_PyType_GetName(tp); PyErr_Format(PyExc_AttributeError, #if PY_MAJOR_VERSION >= 3 "'" __Pyx_FMT_TYPENAME "' object has no attribute '%U'", type_name, name); #else "'" __Pyx_FMT_TYPENAME "' object has no attribute '%.400s'", type_name, PyString_AS_STRING(name)); #endif __Pyx_DECREF_TypeName(type_name); 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; } /* ValidateBasesTuple */ #if CYTHON_COMPILING_IN_CPYTHON || CYTHON_COMPILING_IN_LIMITED_API || CYTHON_USE_TYPE_SPECS static int __Pyx_validate_bases_tuple(const char *type_name, Py_ssize_t dictoffset, PyObject *bases) { Py_ssize_t i, n; #if CYTHON_ASSUME_SAFE_MACROS n = PyTuple_GET_SIZE(bases); #else n = PyTuple_Size(bases); if (n < 0) return -1; #endif for (i = 1; i < n; i++) { #if CYTHON_AVOID_BORROWED_REFS PyObject *b0 = PySequence_GetItem(bases, i); if (!b0) return -1; #elif CYTHON_ASSUME_SAFE_MACROS PyObject *b0 = PyTuple_GET_ITEM(bases, i); #else PyObject *b0 = PyTuple_GetItem(bases, i); if (!b0) return -1; #endif PyTypeObject *b; #if PY_MAJOR_VERSION < 3 if (PyClass_Check(b0)) { PyErr_Format(PyExc_TypeError, "base class '%.200s' is an old-style class", PyString_AS_STRING(((PyClassObject*)b0)->cl_name)); #if CYTHON_AVOID_BORROWED_REFS Py_DECREF(b0); #endif return -1; } #endif b = (PyTypeObject*) b0; if (!__Pyx_PyType_HasFeature(b, Py_TPFLAGS_HEAPTYPE)) { __Pyx_TypeName b_name = __Pyx_PyType_GetName(b); PyErr_Format(PyExc_TypeError, "base class '" __Pyx_FMT_TYPENAME "' is not a heap type", b_name); __Pyx_DECREF_TypeName(b_name); #if CYTHON_AVOID_BORROWED_REFS Py_DECREF(b0); #endif return -1; } if (dictoffset == 0) { Py_ssize_t b_dictoffset = 0; #if CYTHON_USE_TYPE_SLOTS || CYTHON_COMPILING_IN_PYPY b_dictoffset = b->tp_dictoffset; #else PyObject *py_b_dictoffset = PyObject_GetAttrString((PyObject*)b, "__dictoffset__"); if (!py_b_dictoffset) goto dictoffset_return; b_dictoffset = PyLong_AsSsize_t(py_b_dictoffset); Py_DECREF(py_b_dictoffset); if (b_dictoffset == -1 && PyErr_Occurred()) goto dictoffset_return; #endif if (b_dictoffset) { { __Pyx_TypeName b_name = __Pyx_PyType_GetName(b); PyErr_Format(PyExc_TypeError, "extension type '%.200s' has no __dict__ slot, " "but base type '" __Pyx_FMT_TYPENAME "' has: " "either add 'cdef dict __dict__' to the extension type " "or add '__slots__ = [...]' to the base type", type_name, b_name); __Pyx_DECREF_TypeName(b_name); } #if !(CYTHON_USE_TYPE_SLOTS || CYTHON_COMPILING_IN_PYPY) dictoffset_return: #endif #if CYTHON_AVOID_BORROWED_REFS Py_DECREF(b0); #endif return -1; } } #if CYTHON_AVOID_BORROWED_REFS Py_DECREF(b0); #endif } return 0; } #endif /* PyType_Ready */ static int __Pyx_PyType_Ready(PyTypeObject *t) { #if CYTHON_USE_TYPE_SPECS || !(CYTHON_COMPILING_IN_CPYTHON || CYTHON_COMPILING_IN_LIMITED_API) || defined(PYSTON_MAJOR_VERSION) (void)__Pyx_PyObject_CallMethod0; #if CYTHON_USE_TYPE_SPECS (void)__Pyx_validate_bases_tuple; #endif return PyType_Ready(t); #else int r; PyObject *bases = __Pyx_PyType_GetSlot(t, tp_bases, PyObject*); if (bases && unlikely(__Pyx_validate_bases_tuple(t->tp_name, t->tp_dictoffset, bases) == -1)) return -1; #if PY_VERSION_HEX >= 0x03050000 && !defined(PYSTON_MAJOR_VERSION) { int gc_was_enabled; #if PY_VERSION_HEX >= 0x030A00b1 gc_was_enabled = PyGC_Disable(); (void)__Pyx_PyObject_CallMethod0; #else PyObject *ret, *py_status; PyObject *gc = NULL; #if PY_VERSION_HEX >= 0x030700a1 && (!CYTHON_COMPILING_IN_PYPY || PYPY_VERSION_NUM+0 >= 0x07030400) gc = PyImport_GetModule(__pyx_kp_u_gc); #endif if (unlikely(!gc)) gc = PyImport_Import(__pyx_kp_u_gc); if (unlikely(!gc)) return -1; py_status = __Pyx_PyObject_CallMethod0(gc, __pyx_kp_u_isenabled); if (unlikely(!py_status)) { Py_DECREF(gc); return -1; } gc_was_enabled = __Pyx_PyObject_IsTrue(py_status); Py_DECREF(py_status); if (gc_was_enabled > 0) { ret = __Pyx_PyObject_CallMethod0(gc, __pyx_kp_u_disable); if (unlikely(!ret)) { Py_DECREF(gc); return -1; } Py_DECREF(ret); } else if (unlikely(gc_was_enabled == -1)) { Py_DECREF(gc); return -1; } #endif t->tp_flags |= Py_TPFLAGS_HEAPTYPE; #if PY_VERSION_HEX >= 0x030A0000 t->tp_flags |= Py_TPFLAGS_IMMUTABLETYPE; #endif #else (void)__Pyx_PyObject_CallMethod0; #endif r = PyType_Ready(t); #if PY_VERSION_HEX >= 0x03050000 && !defined(PYSTON_MAJOR_VERSION) t->tp_flags &= ~Py_TPFLAGS_HEAPTYPE; #if PY_VERSION_HEX >= 0x030A00b1 if (gc_was_enabled) PyGC_Enable(); #else if (gc_was_enabled) { PyObject *tp, *v, *tb; PyErr_Fetch(&tp, &v, &tb); ret = __Pyx_PyObject_CallMethod0(gc, __pyx_kp_u_enable); if (likely(ret || r == -1)) { Py_XDECREF(ret); PyErr_Restore(tp, v, tb); } else { Py_XDECREF(tp); Py_XDECREF(v); Py_XDECREF(tb); r = -1; } } Py_DECREF(gc); #endif } #endif return r; #endif } /* SetVTable */ static int __Pyx_SetVtable(PyTypeObject *type, void *vtable) { PyObject *ob = PyCapsule_New(vtable, 0, 0); if (unlikely(!ob)) goto bad; #if CYTHON_COMPILING_IN_LIMITED_API if (unlikely(PyObject_SetAttr((PyObject *) type, __pyx_n_s_pyx_vtable, ob) < 0)) #else if (unlikely(PyDict_SetItem(type->tp_dict, __pyx_n_s_pyx_vtable, ob) < 0)) #endif goto bad; Py_DECREF(ob); return 0; bad: Py_XDECREF(ob); return -1; } /* GetVTable */ static void* __Pyx_GetVtable(PyTypeObject *type) { void* ptr; #if CYTHON_COMPILING_IN_LIMITED_API PyObject *ob = PyObject_GetAttr((PyObject *)type, __pyx_n_s_pyx_vtable); #else PyObject *ob = PyObject_GetItem(type->tp_dict, __pyx_n_s_pyx_vtable); #endif if (!ob) goto bad; ptr = PyCapsule_GetPointer(ob, 0); if (!ptr && !PyErr_Occurred()) PyErr_SetString(PyExc_RuntimeError, "invalid vtable found for imported type"); Py_DECREF(ob); return ptr; bad: Py_XDECREF(ob); return NULL; } /* MergeVTables */ #if !CYTHON_COMPILING_IN_LIMITED_API static int __Pyx_MergeVtables(PyTypeObject *type) { int i; void** base_vtables; __Pyx_TypeName tp_base_name; __Pyx_TypeName base_name; void* unknown = (void*)-1; PyObject* bases = type->tp_bases; int base_depth = 0; { PyTypeObject* base = type->tp_base; while (base) { base_depth += 1; base = base->tp_base; } } base_vtables = (void**) malloc(sizeof(void*) * (size_t)(base_depth + 1)); base_vtables[0] = unknown; for (i = 1; i < PyTuple_GET_SIZE(bases); i++) { void* base_vtable = __Pyx_GetVtable(((PyTypeObject*)PyTuple_GET_ITEM(bases, i))); if (base_vtable != NULL) { int j; PyTypeObject* base = type->tp_base; for (j = 0; j < base_depth; j++) { if (base_vtables[j] == unknown) { base_vtables[j] = __Pyx_GetVtable(base); base_vtables[j + 1] = unknown; } if (base_vtables[j] == base_vtable) { break; } else if (base_vtables[j] == NULL) { goto bad; } base = base->tp_base; } } } PyErr_Clear(); free(base_vtables); return 0; bad: tp_base_name = __Pyx_PyType_GetName(type->tp_base); base_name = __Pyx_PyType_GetName((PyTypeObject*)PyTuple_GET_ITEM(bases, i)); PyErr_Format(PyExc_TypeError, "multiple bases have vtable conflict: '" __Pyx_FMT_TYPENAME "' and '" __Pyx_FMT_TYPENAME "'", tp_base_name, base_name); __Pyx_DECREF_TypeName(tp_base_name); __Pyx_DECREF_TypeName(base_name); free(base_vtables); return -1; } #endif /* SetupReduce */ #if !CYTHON_COMPILING_IN_LIMITED_API static int __Pyx_setup_reduce_is_named(PyObject* meth, PyObject* name) { int ret; PyObject *name_attr; name_attr = __Pyx_PyObject_GetAttrStrNoError(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_GetAttrStrNoError(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()) { __Pyx_TypeName type_obj_name = __Pyx_PyType_GetName((PyTypeObject*)type_obj); PyErr_Format(PyExc_RuntimeError, "Unable to initialize pickling for " __Pyx_FMT_TYPENAME, type_obj_name); __Pyx_DECREF_TypeName(type_obj_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; } #endif /* TypeImport */ #ifndef __PYX_HAVE_RT_ImportType_3_0_10 #define __PYX_HAVE_RT_ImportType_3_0_10 static PyTypeObject *__Pyx_ImportType_3_0_10(PyObject *module, const char *module_name, const char *class_name, size_t size, size_t alignment, enum __Pyx_ImportType_CheckSize_3_0_10 check_size) { PyObject *result = 0; char warning[200]; Py_ssize_t basicsize; Py_ssize_t itemsize; #if CYTHON_COMPILING_IN_LIMITED_API PyObject *py_basicsize; PyObject *py_itemsize; #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; } #if !CYTHON_COMPILING_IN_LIMITED_API basicsize = ((PyTypeObject *)result)->tp_basicsize; itemsize = ((PyTypeObject *)result)->tp_itemsize; #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; py_itemsize = PyObject_GetAttrString(result, "__itemsize__"); if (!py_itemsize) goto bad; itemsize = PyLong_AsSsize_t(py_itemsize); Py_DECREF(py_itemsize); py_itemsize = 0; if (itemsize == (Py_ssize_t)-1 && PyErr_Occurred()) goto bad; #endif if (itemsize) { if (size % alignment) { alignment = size % alignment; } if (itemsize < (Py_ssize_t)alignment) itemsize = (Py_ssize_t)alignment; } if ((size_t)(basicsize + itemsize) < 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+itemsize); goto bad; } if (check_size == __Pyx_ImportType_CheckSize_Error_3_0_10 && ((size_t)basicsize > size || (size_t)(basicsize + itemsize) < size)) { PyErr_Format(PyExc_ValueError, "%.200s.%.200s size changed, may indicate binary incompatibility. " "Expected %zd from C header, got %zd-%zd from PyObject", module_name, class_name, size, basicsize, basicsize+itemsize); goto bad; } else if (check_size == __Pyx_ImportType_CheckSize_Warn_3_0_10 && (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 /* FetchSharedCythonModule */ static PyObject *__Pyx_FetchSharedCythonABIModule(void) { return __Pyx_PyImport_AddModuleRef((char*) __PYX_ABI_MODULE_NAME); } /* FetchCommonType */ static int __Pyx_VerifyCachedType(PyObject *cached_type, const char *name, Py_ssize_t basicsize, Py_ssize_t expected_basicsize) { if (!PyType_Check(cached_type)) { PyErr_Format(PyExc_TypeError, "Shared Cython type %.200s is not a type object", name); return -1; } if (basicsize != expected_basicsize) { PyErr_Format(PyExc_TypeError, "Shared Cython type %.200s has the wrong size, try recompiling", name); return -1; } return 0; } #if !CYTHON_USE_TYPE_SPECS static PyTypeObject* __Pyx_FetchCommonType(PyTypeObject* type) { PyObject* abi_module; const char* object_name; PyTypeObject *cached_type = NULL; abi_module = __Pyx_FetchSharedCythonABIModule(); if (!abi_module) return NULL; object_name = strrchr(type->tp_name, '.'); object_name = object_name ? object_name+1 : type->tp_name; cached_type = (PyTypeObject*) PyObject_GetAttrString(abi_module, object_name); if (cached_type) { if (__Pyx_VerifyCachedType( (PyObject *)cached_type, object_name, cached_type->tp_basicsize, type->tp_basicsize) < 0) { goto bad; } goto done; } if (!PyErr_ExceptionMatches(PyExc_AttributeError)) goto bad; PyErr_Clear(); if (PyType_Ready(type) < 0) goto bad; if (PyObject_SetAttrString(abi_module, object_name, (PyObject *)type) < 0) goto bad; Py_INCREF(type); cached_type = type; done: Py_DECREF(abi_module); return cached_type; bad: Py_XDECREF(cached_type); cached_type = NULL; goto done; } #else static PyTypeObject *__Pyx_FetchCommonTypeFromSpec(PyObject *module, PyType_Spec *spec, PyObject *bases) { PyObject *abi_module, *cached_type = NULL; const char* object_name = strrchr(spec->name, '.'); object_name = object_name ? object_name+1 : spec->name; abi_module = __Pyx_FetchSharedCythonABIModule(); if (!abi_module) return NULL; cached_type = PyObject_GetAttrString(abi_module, object_name); if (cached_type) { Py_ssize_t basicsize; #if CYTHON_COMPILING_IN_LIMITED_API PyObject *py_basicsize; py_basicsize = PyObject_GetAttrString(cached_type, "__basicsize__"); if (unlikely(!py_basicsize)) goto bad; basicsize = PyLong_AsSsize_t(py_basicsize); Py_DECREF(py_basicsize); py_basicsize = 0; if (unlikely(basicsize == (Py_ssize_t)-1) && PyErr_Occurred()) goto bad; #else basicsize = likely(PyType_Check(cached_type)) ? ((PyTypeObject*) cached_type)->tp_basicsize : -1; #endif if (__Pyx_VerifyCachedType( cached_type, object_name, basicsize, spec->basicsize) < 0) { goto bad; } goto done; } if (!PyErr_ExceptionMatches(PyExc_AttributeError)) goto bad; PyErr_Clear(); CYTHON_UNUSED_VAR(module); cached_type = __Pyx_PyType_FromModuleAndSpec(abi_module, spec, bases); if (unlikely(!cached_type)) goto bad; if (unlikely(__Pyx_fix_up_extension_type_from_spec(spec, (PyTypeObject *) cached_type) < 0)) goto bad; if (PyObject_SetAttrString(abi_module, object_name, cached_type) < 0) goto bad; done: Py_DECREF(abi_module); assert(cached_type == NULL || PyType_Check(cached_type)); return (PyTypeObject *) cached_type; bad: Py_XDECREF(cached_type); cached_type = NULL; goto done; } #endif /* PyVectorcallFastCallDict */ #if CYTHON_METH_FASTCALL static PyObject *__Pyx_PyVectorcall_FastCallDict_kw(PyObject *func, __pyx_vectorcallfunc vc, PyObject *const *args, size_t nargs, PyObject *kw) { PyObject *res = NULL; PyObject *kwnames; PyObject **newargs; PyObject **kwvalues; Py_ssize_t i, pos; size_t j; PyObject *key, *value; unsigned long keys_are_strings; Py_ssize_t nkw = PyDict_GET_SIZE(kw); newargs = (PyObject **)PyMem_Malloc((nargs + (size_t)nkw) * sizeof(args[0])); if (unlikely(newargs == NULL)) { PyErr_NoMemory(); return NULL; } for (j = 0; j < nargs; j++) newargs[j] = args[j]; kwnames = PyTuple_New(nkw); if (unlikely(kwnames == NULL)) { PyMem_Free(newargs); return NULL; } kwvalues = newargs + nargs; pos = i = 0; keys_are_strings = Py_TPFLAGS_UNICODE_SUBCLASS; while (PyDict_Next(kw, &pos, &key, &value)) { keys_are_strings &= Py_TYPE(key)->tp_flags; Py_INCREF(key); Py_INCREF(value); PyTuple_SET_ITEM(kwnames, i, key); kwvalues[i] = value; i++; } if (unlikely(!keys_are_strings)) { PyErr_SetString(PyExc_TypeError, "keywords must be strings"); goto cleanup; } res = vc(func, newargs, nargs, kwnames); cleanup: Py_DECREF(kwnames); for (i = 0; i < nkw; i++) Py_DECREF(kwvalues[i]); PyMem_Free(newargs); return res; } static CYTHON_INLINE PyObject *__Pyx_PyVectorcall_FastCallDict(PyObject *func, __pyx_vectorcallfunc vc, PyObject *const *args, size_t nargs, PyObject *kw) { if (likely(kw == NULL) || PyDict_GET_SIZE(kw) == 0) { return vc(func, args, nargs, NULL); } return __Pyx_PyVectorcall_FastCallDict_kw(func, vc, args, nargs, kw); } #endif /* CythonFunctionShared */ #if CYTHON_COMPILING_IN_LIMITED_API static CYTHON_INLINE int __Pyx__IsSameCyOrCFunction(PyObject *func, void *cfunc) { if (__Pyx_CyFunction_Check(func)) { return PyCFunction_GetFunction(((__pyx_CyFunctionObject*)func)->func) == (PyCFunction) cfunc; } else if (PyCFunction_Check(func)) { return PyCFunction_GetFunction(func) == (PyCFunction) cfunc; } return 0; } #else static CYTHON_INLINE int __Pyx__IsSameCyOrCFunction(PyObject *func, void *cfunc) { return __Pyx_CyOrPyCFunction_Check(func) && __Pyx_CyOrPyCFunction_GET_FUNCTION(func) == (PyCFunction) cfunc; } #endif static CYTHON_INLINE void __Pyx__CyFunction_SetClassObj(__pyx_CyFunctionObject* f, PyObject* classobj) { #if PY_VERSION_HEX < 0x030900B1 || CYTHON_COMPILING_IN_LIMITED_API __Pyx_Py_XDECREF_SET( __Pyx_CyFunction_GetClassObj(f), ((classobj) ? __Pyx_NewRef(classobj) : NULL)); #else __Pyx_Py_XDECREF_SET( ((PyCMethodObject *) (f))->mm_class, (PyTypeObject*)((classobj) ? __Pyx_NewRef(classobj) : NULL)); #endif } static PyObject * __Pyx_CyFunction_get_doc(__pyx_CyFunctionObject *op, void *closure) { CYTHON_UNUSED_VAR(closure); if (unlikely(op->func_doc == NULL)) { #if CYTHON_COMPILING_IN_LIMITED_API op->func_doc = PyObject_GetAttrString(op->func, "__doc__"); if (unlikely(!op->func_doc)) return NULL; #else if (((PyCFunctionObject*)op)->m_ml->ml_doc) { #if PY_MAJOR_VERSION >= 3 op->func_doc = PyUnicode_FromString(((PyCFunctionObject*)op)->m_ml->ml_doc); #else op->func_doc = PyString_FromString(((PyCFunctionObject*)op)->m_ml->ml_doc); #endif if (unlikely(op->func_doc == NULL)) return NULL; } else { Py_INCREF(Py_None); return Py_None; } #endif } Py_INCREF(op->func_doc); return op->func_doc; } static int __Pyx_CyFunction_set_doc(__pyx_CyFunctionObject *op, PyObject *value, void *context) { CYTHON_UNUSED_VAR(context); if (value == NULL) { value = Py_None; } Py_INCREF(value); __Pyx_Py_XDECREF_SET(op->func_doc, value); return 0; } static PyObject * __Pyx_CyFunction_get_name(__pyx_CyFunctionObject *op, void *context) { CYTHON_UNUSED_VAR(context); if (unlikely(op->func_name == NULL)) { #if CYTHON_COMPILING_IN_LIMITED_API op->func_name = PyObject_GetAttrString(op->func, "__name__"); #elif PY_MAJOR_VERSION >= 3 op->func_name = PyUnicode_InternFromString(((PyCFunctionObject*)op)->m_ml->ml_name); #else op->func_name = PyString_InternFromString(((PyCFunctionObject*)op)->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, void *context) { CYTHON_UNUSED_VAR(context); #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; } Py_INCREF(value); __Pyx_Py_XDECREF_SET(op->func_name, value); return 0; } static PyObject * __Pyx_CyFunction_get_qualname(__pyx_CyFunctionObject *op, void *context) { CYTHON_UNUSED_VAR(context); Py_INCREF(op->func_qualname); return op->func_qualname; } static int __Pyx_CyFunction_set_qualname(__pyx_CyFunctionObject *op, PyObject *value, void *context) { CYTHON_UNUSED_VAR(context); #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; } Py_INCREF(value); __Pyx_Py_XDECREF_SET(op->func_qualname, value); return 0; } static PyObject * __Pyx_CyFunction_get_dict(__pyx_CyFunctionObject *op, void *context) { CYTHON_UNUSED_VAR(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, void *context) { CYTHON_UNUSED_VAR(context); 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; } Py_INCREF(value); __Pyx_Py_XDECREF_SET(op->func_dict, value); return 0; } static PyObject * __Pyx_CyFunction_get_globals(__pyx_CyFunctionObject *op, void *context) { CYTHON_UNUSED_VAR(context); Py_INCREF(op->func_globals); return op->func_globals; } static PyObject * __Pyx_CyFunction_get_closure(__pyx_CyFunctionObject *op, void *context) { CYTHON_UNUSED_VAR(op); CYTHON_UNUSED_VAR(context); Py_INCREF(Py_None); return Py_None; } static PyObject * __Pyx_CyFunction_get_code(__pyx_CyFunctionObject *op, void *context) { PyObject* result = (op->func_code) ? op->func_code : Py_None; CYTHON_UNUSED_VAR(context); 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 = __Pyx_PySequence_ITEM(res, 0); if (unlikely(!op->defaults_tuple)) result = -1; else { op->defaults_kwdict = __Pyx_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, void *context) { CYTHON_UNUSED_VAR(context); if (!value) { value = Py_None; } else if (unlikely(value != Py_None && !PyTuple_Check(value))) { PyErr_SetString(PyExc_TypeError, "__defaults__ must be set to a tuple object"); return -1; } PyErr_WarnEx(PyExc_RuntimeWarning, "changes to cyfunction.__defaults__ will not " "currently affect the values used in function calls", 1); Py_INCREF(value); __Pyx_Py_XDECREF_SET(op->defaults_tuple, value); return 0; } static PyObject * __Pyx_CyFunction_get_defaults(__pyx_CyFunctionObject *op, void *context) { PyObject* result = op->defaults_tuple; CYTHON_UNUSED_VAR(context); if (unlikely(!result)) { if (op->defaults_getter) { if (unlikely(__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, void *context) { CYTHON_UNUSED_VAR(context); if (!value) { value = Py_None; } else if (unlikely(value != Py_None && !PyDict_Check(value))) { PyErr_SetString(PyExc_TypeError, "__kwdefaults__ must be set to a dict object"); return -1; } PyErr_WarnEx(PyExc_RuntimeWarning, "changes to cyfunction.__kwdefaults__ will not " "currently affect the values used in function calls", 1); Py_INCREF(value); __Pyx_Py_XDECREF_SET(op->defaults_kwdict, value); return 0; } static PyObject * __Pyx_CyFunction_get_kwdefaults(__pyx_CyFunctionObject *op, void *context) { PyObject* result = op->defaults_kwdict; CYTHON_UNUSED_VAR(context); if (unlikely(!result)) { if (op->defaults_getter) { if (unlikely(__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, void *context) { CYTHON_UNUSED_VAR(context); if (!value || value == Py_None) { value = NULL; } else if (unlikely(!PyDict_Check(value))) { PyErr_SetString(PyExc_TypeError, "__annotations__ must be set to a dict object"); return -1; } Py_XINCREF(value); __Pyx_Py_XDECREF_SET(op->func_annotations, value); return 0; } static PyObject * __Pyx_CyFunction_get_annotations(__pyx_CyFunctionObject *op, void *context) { PyObject* result = op->func_annotations; CYTHON_UNUSED_VAR(context); if (unlikely(!result)) { result = PyDict_New(); if (unlikely(!result)) return NULL; op->func_annotations = result; } Py_INCREF(result); return result; } static PyObject * __Pyx_CyFunction_get_is_coroutine(__pyx_CyFunctionObject *op, void *context) { int is_coroutine; CYTHON_UNUSED_VAR(context); if (op->func_is_coroutine) { return __Pyx_NewRef(op->func_is_coroutine); } is_coroutine = op->flags & __Pyx_CYFUNCTION_COROUTINE; #if PY_VERSION_HEX >= 0x03050000 if (is_coroutine) { PyObject *module, *fromlist, *marker = __pyx_n_s_is_coroutine; fromlist = PyList_New(1); if (unlikely(!fromlist)) return NULL; Py_INCREF(marker); #if CYTHON_ASSUME_SAFE_MACROS PyList_SET_ITEM(fromlist, 0, marker); #else if (unlikely(PyList_SetItem(fromlist, 0, marker) < 0)) { Py_DECREF(marker); Py_DECREF(fromlist); return NULL; } #endif module = PyImport_ImportModuleLevelObject(__pyx_n_s_asyncio_coroutines, NULL, NULL, fromlist, 0); Py_DECREF(fromlist); if (unlikely(!module)) goto ignore; op->func_is_coroutine = __Pyx_PyObject_GetAttrStr(module, marker); Py_DECREF(module); if (likely(op->func_is_coroutine)) { return __Pyx_NewRef(op->func_is_coroutine); } ignore: PyErr_Clear(); } #endif op->func_is_coroutine = __Pyx_PyBool_FromLong(is_coroutine); return __Pyx_NewRef(op->func_is_coroutine); } #if CYTHON_COMPILING_IN_LIMITED_API static PyObject * __Pyx_CyFunction_get_module(__pyx_CyFunctionObject *op, void *context) { CYTHON_UNUSED_VAR(context); return PyObject_GetAttrString(op->func, "__module__"); } static int __Pyx_CyFunction_set_module(__pyx_CyFunctionObject *op, PyObject* value, void *context) { CYTHON_UNUSED_VAR(context); return PyObject_SetAttrString(op->func, "__module__", value); } #endif 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 *) "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}, {(char *) "_is_coroutine", (getter)__Pyx_CyFunction_get_is_coroutine, 0, 0, 0}, #if CYTHON_COMPILING_IN_LIMITED_API {"__module__", (getter)__Pyx_CyFunction_get_module, (setter)__Pyx_CyFunction_set_module, 0, 0}, #endif {0, 0, 0, 0, 0} }; static PyMemberDef __pyx_CyFunction_members[] = { #if !CYTHON_COMPILING_IN_LIMITED_API {(char *) "__module__", T_OBJECT, offsetof(PyCFunctionObject, m_module), 0, 0}, #endif #if CYTHON_USE_TYPE_SPECS {(char *) "__dictoffset__", T_PYSSIZET, offsetof(__pyx_CyFunctionObject, func_dict), READONLY, 0}, #if CYTHON_METH_FASTCALL #if CYTHON_BACKPORT_VECTORCALL {(char *) "__vectorcalloffset__", T_PYSSIZET, offsetof(__pyx_CyFunctionObject, func_vectorcall), READONLY, 0}, #else #if !CYTHON_COMPILING_IN_LIMITED_API {(char *) "__vectorcalloffset__", T_PYSSIZET, offsetof(PyCFunctionObject, vectorcall), READONLY, 0}, #endif #endif #endif #if PY_VERSION_HEX < 0x030500A0 || CYTHON_COMPILING_IN_LIMITED_API {(char *) "__weaklistoffset__", T_PYSSIZET, offsetof(__pyx_CyFunctionObject, func_weakreflist), READONLY, 0}, #else {(char *) "__weaklistoffset__", T_PYSSIZET, offsetof(PyCFunctionObject, m_weakreflist), READONLY, 0}, #endif #endif {0, 0, 0, 0, 0} }; static PyObject * __Pyx_CyFunction_reduce(__pyx_CyFunctionObject *m, PyObject *args) { CYTHON_UNUSED_VAR(args); #if PY_MAJOR_VERSION >= 3 Py_INCREF(m->func_qualname); return m->func_qualname; #else return PyString_FromString(((PyCFunctionObject*)m)->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 || CYTHON_COMPILING_IN_LIMITED_API #define __Pyx_CyFunction_weakreflist(cyfunc) ((cyfunc)->func_weakreflist) #else #define __Pyx_CyFunction_weakreflist(cyfunc) (((PyCFunctionObject*)cyfunc)->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 !CYTHON_COMPILING_IN_LIMITED_API PyCFunctionObject *cf = (PyCFunctionObject*) op; #endif if (unlikely(op == NULL)) return NULL; #if CYTHON_COMPILING_IN_LIMITED_API op->func = PyCFunction_NewEx(ml, (PyObject*)op, module); if (unlikely(!op->func)) return NULL; #endif op->flags = flags; __Pyx_CyFunction_weakreflist(op) = NULL; #if !CYTHON_COMPILING_IN_LIMITED_API cf->m_ml = ml; cf->m_self = (PyObject *) op; #endif Py_XINCREF(closure); op->func_closure = closure; #if !CYTHON_COMPILING_IN_LIMITED_API Py_XINCREF(module); cf->m_module = module; #endif op->func_dict = NULL; op->func_name = NULL; Py_INCREF(qualname); op->func_qualname = qualname; op->func_doc = NULL; #if PY_VERSION_HEX < 0x030900B1 || CYTHON_COMPILING_IN_LIMITED_API op->func_classobj = NULL; #else ((PyCMethodObject*)op)->mm_class = NULL; #endif 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; op->func_is_coroutine = NULL; #if CYTHON_METH_FASTCALL switch (ml->ml_flags & (METH_VARARGS | METH_FASTCALL | METH_NOARGS | METH_O | METH_KEYWORDS | METH_METHOD)) { case METH_NOARGS: __Pyx_CyFunction_func_vectorcall(op) = __Pyx_CyFunction_Vectorcall_NOARGS; break; case METH_O: __Pyx_CyFunction_func_vectorcall(op) = __Pyx_CyFunction_Vectorcall_O; break; case METH_METHOD | METH_FASTCALL | METH_KEYWORDS: __Pyx_CyFunction_func_vectorcall(op) = __Pyx_CyFunction_Vectorcall_FASTCALL_KEYWORDS_METHOD; break; case METH_FASTCALL | METH_KEYWORDS: __Pyx_CyFunction_func_vectorcall(op) = __Pyx_CyFunction_Vectorcall_FASTCALL_KEYWORDS; break; case METH_VARARGS | METH_KEYWORDS: __Pyx_CyFunction_func_vectorcall(op) = NULL; break; default: PyErr_SetString(PyExc_SystemError, "Bad call flags for CyFunction"); Py_DECREF(op); return NULL; } #endif return (PyObject *) op; } static int __Pyx_CyFunction_clear(__pyx_CyFunctionObject *m) { Py_CLEAR(m->func_closure); #if CYTHON_COMPILING_IN_LIMITED_API Py_CLEAR(m->func); #else Py_CLEAR(((PyCFunctionObject*)m)->m_module); #endif 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); #if !CYTHON_COMPILING_IN_LIMITED_API #if PY_VERSION_HEX < 0x030900B1 Py_CLEAR(__Pyx_CyFunction_GetClassObj(m)); #else { PyObject *cls = (PyObject*) ((PyCMethodObject *) (m))->mm_class; ((PyCMethodObject *) (m))->mm_class = NULL; Py_XDECREF(cls); } #endif #endif Py_CLEAR(m->defaults_tuple); Py_CLEAR(m->defaults_kwdict); Py_CLEAR(m->func_annotations); Py_CLEAR(m->func_is_coroutine); 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); __Pyx_PyHeapTypeObject_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); #if CYTHON_COMPILING_IN_LIMITED_API Py_VISIT(m->func); #else Py_VISIT(((PyCFunctionObject*)m)->m_module); #endif 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); #if !CYTHON_COMPILING_IN_LIMITED_API Py_VISIT(__Pyx_CyFunction_GetClassObj(m)); #endif Py_VISIT(m->defaults_tuple); Py_VISIT(m->defaults_kwdict); Py_VISIT(m->func_is_coroutine); 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_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) { #if CYTHON_COMPILING_IN_LIMITED_API PyObject *f = ((__pyx_CyFunctionObject*)func)->func; PyObject *py_name = NULL; PyCFunction meth; int flags; meth = PyCFunction_GetFunction(f); if (unlikely(!meth)) return NULL; flags = PyCFunction_GetFlags(f); if (unlikely(flags < 0)) return NULL; #else PyCFunctionObject* f = (PyCFunctionObject*)func; PyCFunction meth = f->m_ml->ml_meth; int flags = f->m_ml->ml_flags; #endif Py_ssize_t size; switch (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)) { #if CYTHON_ASSUME_SAFE_MACROS size = PyTuple_GET_SIZE(arg); #else size = PyTuple_Size(arg); if (unlikely(size < 0)) return NULL; #endif if (likely(size == 0)) return (*meth)(self, NULL); #if CYTHON_COMPILING_IN_LIMITED_API py_name = __Pyx_CyFunction_get_name((__pyx_CyFunctionObject*)func, NULL); if (!py_name) return NULL; PyErr_Format(PyExc_TypeError, "%.200S() takes no arguments (%" CYTHON_FORMAT_SSIZE_T "d given)", py_name, size); Py_DECREF(py_name); #else PyErr_Format(PyExc_TypeError, "%.200s() takes no arguments (%" CYTHON_FORMAT_SSIZE_T "d given)", f->m_ml->ml_name, size); #endif return NULL; } break; case METH_O: if (likely(kw == NULL || PyDict_Size(kw) == 0)) { #if CYTHON_ASSUME_SAFE_MACROS size = PyTuple_GET_SIZE(arg); #else size = PyTuple_Size(arg); if (unlikely(size < 0)) return NULL; #endif if (likely(size == 1)) { PyObject *result, *arg0; #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS arg0 = PyTuple_GET_ITEM(arg, 0); #else arg0 = __Pyx_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; } #if CYTHON_COMPILING_IN_LIMITED_API py_name = __Pyx_CyFunction_get_name((__pyx_CyFunctionObject*)func, NULL); if (!py_name) return NULL; PyErr_Format(PyExc_TypeError, "%.200S() takes exactly one argument (%" CYTHON_FORMAT_SSIZE_T "d given)", py_name, size); Py_DECREF(py_name); #else PyErr_Format(PyExc_TypeError, "%.200s() takes exactly one argument (%" CYTHON_FORMAT_SSIZE_T "d given)", f->m_ml->ml_name, size); #endif return NULL; } break; default: PyErr_SetString(PyExc_SystemError, "Bad call flags for CyFunction"); return NULL; } #if CYTHON_COMPILING_IN_LIMITED_API py_name = __Pyx_CyFunction_get_name((__pyx_CyFunctionObject*)func, NULL); if (!py_name) return NULL; PyErr_Format(PyExc_TypeError, "%.200S() takes no keyword arguments", py_name); Py_DECREF(py_name); #else PyErr_Format(PyExc_TypeError, "%.200s() takes no keyword arguments", f->m_ml->ml_name); #endif return NULL; } static CYTHON_INLINE PyObject *__Pyx_CyFunction_Call(PyObject *func, PyObject *arg, PyObject *kw) { PyObject *self, *result; #if CYTHON_COMPILING_IN_LIMITED_API self = PyCFunction_GetSelf(((__pyx_CyFunctionObject*)func)->func); if (unlikely(!self) && PyErr_Occurred()) return NULL; #else self = ((PyCFunctionObject*)func)->m_self; #endif result = __Pyx_CyFunction_CallMethod(func, self, arg, kw); return result; } static PyObject *__Pyx_CyFunction_CallAsMethod(PyObject *func, PyObject *args, PyObject *kw) { PyObject *result; __pyx_CyFunctionObject *cyfunc = (__pyx_CyFunctionObject *) func; #if CYTHON_METH_FASTCALL __pyx_vectorcallfunc vc = __Pyx_CyFunction_func_vectorcall(cyfunc); if (vc) { #if CYTHON_ASSUME_SAFE_MACROS return __Pyx_PyVectorcall_FastCallDict(func, vc, &PyTuple_GET_ITEM(args, 0), (size_t)PyTuple_GET_SIZE(args), kw); #else (void) &__Pyx_PyVectorcall_FastCallDict; return PyVectorcall_Call(func, args, kw); #endif } #endif if ((cyfunc->flags & __Pyx_CYFUNCTION_CCLASS) && !(cyfunc->flags & __Pyx_CYFUNCTION_STATICMETHOD)) { Py_ssize_t argc; PyObject *new_args; PyObject *self; #if CYTHON_ASSUME_SAFE_MACROS argc = PyTuple_GET_SIZE(args); #else argc = PyTuple_Size(args); if (unlikely(!argc) < 0) return NULL; #endif 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); #if PY_MAJOR_VERSION > 2 PyErr_Format(PyExc_TypeError, "unbound method %.200S() needs an argument", cyfunc->func_qualname); #else PyErr_SetString(PyExc_TypeError, "unbound method needs an argument"); #endif 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; } #if CYTHON_METH_FASTCALL static CYTHON_INLINE int __Pyx_CyFunction_Vectorcall_CheckArgs(__pyx_CyFunctionObject *cyfunc, Py_ssize_t nargs, PyObject *kwnames) { int ret = 0; if ((cyfunc->flags & __Pyx_CYFUNCTION_CCLASS) && !(cyfunc->flags & __Pyx_CYFUNCTION_STATICMETHOD)) { if (unlikely(nargs < 1)) { PyErr_Format(PyExc_TypeError, "%.200s() needs an argument", ((PyCFunctionObject*)cyfunc)->m_ml->ml_name); return -1; } ret = 1; } if (unlikely(kwnames) && unlikely(PyTuple_GET_SIZE(kwnames))) { PyErr_Format(PyExc_TypeError, "%.200s() takes no keyword arguments", ((PyCFunctionObject*)cyfunc)->m_ml->ml_name); return -1; } return ret; } static PyObject * __Pyx_CyFunction_Vectorcall_NOARGS(PyObject *func, PyObject *const *args, size_t nargsf, PyObject *kwnames) { __pyx_CyFunctionObject *cyfunc = (__pyx_CyFunctionObject *)func; PyMethodDef* def = ((PyCFunctionObject*)cyfunc)->m_ml; #if CYTHON_BACKPORT_VECTORCALL Py_ssize_t nargs = (Py_ssize_t)nargsf; #else Py_ssize_t nargs = PyVectorcall_NARGS(nargsf); #endif PyObject *self; switch (__Pyx_CyFunction_Vectorcall_CheckArgs(cyfunc, nargs, kwnames)) { case 1: self = args[0]; args += 1; nargs -= 1; break; case 0: self = ((PyCFunctionObject*)cyfunc)->m_self; break; default: return NULL; } if (unlikely(nargs != 0)) { PyErr_Format(PyExc_TypeError, "%.200s() takes no arguments (%" CYTHON_FORMAT_SSIZE_T "d given)", def->ml_name, nargs); return NULL; } return def->ml_meth(self, NULL); } static PyObject * __Pyx_CyFunction_Vectorcall_O(PyObject *func, PyObject *const *args, size_t nargsf, PyObject *kwnames) { __pyx_CyFunctionObject *cyfunc = (__pyx_CyFunctionObject *)func; PyMethodDef* def = ((PyCFunctionObject*)cyfunc)->m_ml; #if CYTHON_BACKPORT_VECTORCALL Py_ssize_t nargs = (Py_ssize_t)nargsf; #else Py_ssize_t nargs = PyVectorcall_NARGS(nargsf); #endif PyObject *self; switch (__Pyx_CyFunction_Vectorcall_CheckArgs(cyfunc, nargs, kwnames)) { case 1: self = args[0]; args += 1; nargs -= 1; break; case 0: self = ((PyCFunctionObject*)cyfunc)->m_self; break; default: return NULL; } if (unlikely(nargs != 1)) { PyErr_Format(PyExc_TypeError, "%.200s() takes exactly one argument (%" CYTHON_FORMAT_SSIZE_T "d given)", def->ml_name, nargs); return NULL; } return def->ml_meth(self, args[0]); } static PyObject * __Pyx_CyFunction_Vectorcall_FASTCALL_KEYWORDS(PyObject *func, PyObject *const *args, size_t nargsf, PyObject *kwnames) { __pyx_CyFunctionObject *cyfunc = (__pyx_CyFunctionObject *)func; PyMethodDef* def = ((PyCFunctionObject*)cyfunc)->m_ml; #if CYTHON_BACKPORT_VECTORCALL Py_ssize_t nargs = (Py_ssize_t)nargsf; #else Py_ssize_t nargs = PyVectorcall_NARGS(nargsf); #endif PyObject *self; switch (__Pyx_CyFunction_Vectorcall_CheckArgs(cyfunc, nargs, NULL)) { case 1: self = args[0]; args += 1; nargs -= 1; break; case 0: self = ((PyCFunctionObject*)cyfunc)->m_self; break; default: return NULL; } return ((__Pyx_PyCFunctionFastWithKeywords)(void(*)(void))def->ml_meth)(self, args, nargs, kwnames); } static PyObject * __Pyx_CyFunction_Vectorcall_FASTCALL_KEYWORDS_METHOD(PyObject *func, PyObject *const *args, size_t nargsf, PyObject *kwnames) { __pyx_CyFunctionObject *cyfunc = (__pyx_CyFunctionObject *)func; PyMethodDef* def = ((PyCFunctionObject*)cyfunc)->m_ml; PyTypeObject *cls = (PyTypeObject *) __Pyx_CyFunction_GetClassObj(cyfunc); #if CYTHON_BACKPORT_VECTORCALL Py_ssize_t nargs = (Py_ssize_t)nargsf; #else Py_ssize_t nargs = PyVectorcall_NARGS(nargsf); #endif PyObject *self; switch (__Pyx_CyFunction_Vectorcall_CheckArgs(cyfunc, nargs, NULL)) { case 1: self = args[0]; args += 1; nargs -= 1; break; case 0: self = ((PyCFunctionObject*)cyfunc)->m_self; break; default: return NULL; } return ((__Pyx_PyCMethod)(void(*)(void))def->ml_meth)(self, cls, args, (size_t)nargs, kwnames); } #endif #if CYTHON_USE_TYPE_SPECS static PyType_Slot __pyx_CyFunctionType_slots[] = { {Py_tp_dealloc, (void *)__Pyx_CyFunction_dealloc}, {Py_tp_repr, (void *)__Pyx_CyFunction_repr}, {Py_tp_call, (void *)__Pyx_CyFunction_CallAsMethod}, {Py_tp_traverse, (void *)__Pyx_CyFunction_traverse}, {Py_tp_clear, (void *)__Pyx_CyFunction_clear}, {Py_tp_methods, (void *)__pyx_CyFunction_methods}, {Py_tp_members, (void *)__pyx_CyFunction_members}, {Py_tp_getset, (void *)__pyx_CyFunction_getsets}, {Py_tp_descr_get, (void *)__Pyx_PyMethod_New}, {0, 0}, }; static PyType_Spec __pyx_CyFunctionType_spec = { __PYX_TYPE_MODULE_PREFIX "cython_function_or_method", sizeof(__pyx_CyFunctionObject), 0, #ifdef Py_TPFLAGS_METHOD_DESCRIPTOR Py_TPFLAGS_METHOD_DESCRIPTOR | #endif #if (defined(_Py_TPFLAGS_HAVE_VECTORCALL) && CYTHON_METH_FASTCALL) _Py_TPFLAGS_HAVE_VECTORCALL | #endif Py_TPFLAGS_DEFAULT | Py_TPFLAGS_HAVE_GC | Py_TPFLAGS_BASETYPE, __pyx_CyFunctionType_slots }; #else static PyTypeObject __pyx_CyFunctionType_type = { PyVarObject_HEAD_INIT(0, 0) __PYX_TYPE_MODULE_PREFIX "cython_function_or_method", sizeof(__pyx_CyFunctionObject), 0, (destructor) __Pyx_CyFunction_dealloc, #if !CYTHON_METH_FASTCALL 0, #elif CYTHON_BACKPORT_VECTORCALL (printfunc)offsetof(__pyx_CyFunctionObject, func_vectorcall), #else offsetof(PyCFunctionObject, vectorcall), #endif 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, #ifdef Py_TPFLAGS_METHOD_DESCRIPTOR Py_TPFLAGS_METHOD_DESCRIPTOR | #endif #if defined(_Py_TPFLAGS_HAVE_VECTORCALL) && CYTHON_METH_FASTCALL _Py_TPFLAGS_HAVE_VECTORCALL | #endif Py_TPFLAGS_DEFAULT | Py_TPFLAGS_HAVE_GC | Py_TPFLAGS_BASETYPE, 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_PyMethod_New, 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 __PYX_NEED_TP_PRINT_SLOT 0, #endif #if PY_VERSION_HEX >= 0x030C0000 0, #endif #if CYTHON_COMPILING_IN_PYPY && PY_VERSION_HEX >= 0x03090000 && PY_VERSION_HEX < 0x030a0000 0, #endif }; #endif static int __pyx_CyFunction_init(PyObject *module) { #if CYTHON_USE_TYPE_SPECS __pyx_CyFunctionType = __Pyx_FetchCommonTypeFromSpec(module, &__pyx_CyFunctionType_spec, NULL); #else CYTHON_UNUSED_VAR(module); __pyx_CyFunctionType = __Pyx_FetchCommonType(&__pyx_CyFunctionType_type); #endif 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); } /* CythonFunction */ static PyObject *__Pyx_CyFunction_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_CyFunctionType), ml, flags, qualname, closure, module, globals, code ); if (likely(op)) { PyObject_GC_Track(op); } return op; } /* CLineInTraceback */ #ifndef CYTHON_CLINE_IN_TRACEBACK static int __Pyx_CLineForTraceback(PyThreadState *tstate, int c_line) { PyObject *use_cline; PyObject *ptype, *pvalue, *ptraceback; #if CYTHON_COMPILING_IN_CPYTHON PyObject **cython_runtime_dict; #endif CYTHON_MAYBE_UNUSED_VAR(tstate); 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_GetAttrStrNoError(__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 */ #if !CYTHON_COMPILING_IN_LIMITED_API 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); } #endif /* AddTraceback */ #include "compile.h" #include "frameobject.h" #include "traceback.h" #if PY_VERSION_HEX >= 0x030b00a6 && !CYTHON_COMPILING_IN_LIMITED_API #ifndef Py_BUILD_CORE #define Py_BUILD_CORE 1 #endif #include "internal/pycore_frame.h" #endif #if CYTHON_COMPILING_IN_LIMITED_API static PyObject *__Pyx_PyCode_Replace_For_AddTraceback(PyObject *code, PyObject *scratch_dict, PyObject *firstlineno, PyObject *name) { PyObject *replace = NULL; if (unlikely(PyDict_SetItemString(scratch_dict, "co_firstlineno", firstlineno))) return NULL; if (unlikely(PyDict_SetItemString(scratch_dict, "co_name", name))) return NULL; replace = PyObject_GetAttrString(code, "replace"); if (likely(replace)) { PyObject *result; result = PyObject_Call(replace, __pyx_empty_tuple, scratch_dict); Py_DECREF(replace); return result; } PyErr_Clear(); #if __PYX_LIMITED_VERSION_HEX < 0x030780000 { PyObject *compiled = NULL, *result = NULL; if (unlikely(PyDict_SetItemString(scratch_dict, "code", code))) return NULL; if (unlikely(PyDict_SetItemString(scratch_dict, "type", (PyObject*)(&PyType_Type)))) return NULL; compiled = Py_CompileString( "out = type(code)(\n" " code.co_argcount, code.co_kwonlyargcount, code.co_nlocals, code.co_stacksize,\n" " code.co_flags, code.co_code, code.co_consts, code.co_names,\n" " code.co_varnames, code.co_filename, co_name, co_firstlineno,\n" " code.co_lnotab)\n", "", Py_file_input); if (!compiled) return NULL; result = PyEval_EvalCode(compiled, scratch_dict, scratch_dict); Py_DECREF(compiled); if (!result) PyErr_Print(); Py_DECREF(result); result = PyDict_GetItemString(scratch_dict, "out"); if (result) Py_INCREF(result); return result; } #else return NULL; #endif } static void __Pyx_AddTraceback(const char *funcname, int c_line, int py_line, const char *filename) { PyObject *code_object = NULL, *py_py_line = NULL, *py_funcname = NULL, *dict = NULL; PyObject *replace = NULL, *getframe = NULL, *frame = NULL; PyObject *exc_type, *exc_value, *exc_traceback; int success = 0; if (c_line) { (void) __pyx_cfilenm; (void) __Pyx_CLineForTraceback(__Pyx_PyThreadState_Current, c_line); } PyErr_Fetch(&exc_type, &exc_value, &exc_traceback); code_object = Py_CompileString("_getframe()", filename, Py_eval_input); if (unlikely(!code_object)) goto bad; py_py_line = PyLong_FromLong(py_line); if (unlikely(!py_py_line)) goto bad; py_funcname = PyUnicode_FromString(funcname); if (unlikely(!py_funcname)) goto bad; dict = PyDict_New(); if (unlikely(!dict)) goto bad; { PyObject *old_code_object = code_object; code_object = __Pyx_PyCode_Replace_For_AddTraceback(code_object, dict, py_py_line, py_funcname); Py_DECREF(old_code_object); } if (unlikely(!code_object)) goto bad; getframe = PySys_GetObject("_getframe"); if (unlikely(!getframe)) goto bad; if (unlikely(PyDict_SetItemString(dict, "_getframe", getframe))) goto bad; frame = PyEval_EvalCode(code_object, dict, dict); if (unlikely(!frame) || frame == Py_None) goto bad; success = 1; bad: PyErr_Restore(exc_type, exc_value, exc_traceback); Py_XDECREF(code_object); Py_XDECREF(py_py_line); Py_XDECREF(py_funcname); Py_XDECREF(dict); Py_XDECREF(replace); if (success) { PyTraceBack_Here( (struct _frame*)frame); } Py_XDECREF(frame); } #else 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, 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); 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); } #endif #if PY_MAJOR_VERSION < 3 static int __Pyx_GetBuffer(PyObject *obj, Py_buffer *view, int flags) { __Pyx_TypeName obj_type_name; 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); obj_type_name = __Pyx_PyType_GetName(Py_TYPE(obj)); PyErr_Format(PyExc_TypeError, "'" __Pyx_FMT_TYPENAME "' does not have the buffer interface", obj_type_name); __Pyx_DECREF_TypeName(obj_type_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); } /* 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;\ } /* 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, int ndim, int spec) { CYTHON_UNUSED_VAR(ndim); 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_nn___pyx_t_12astroscrappy_12astroscrappy_bool(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_nn___pyx_t_12astroscrappy_12astroscrappy_bool, stack, &result, obj); if (unlikely(retcode == -1)) goto __pyx_fail; return result; __pyx_fail: result.memview = NULL; result.data = NULL; return result; } /* Declarations */ #if CYTHON_CCOMPLEX && (1) && (!0 || __cplusplus) #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 && (1) && (!0 || __cplusplus) #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) && (a.real >= 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 && (1) && (!0 || __cplusplus) #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 && (1) && (!0 || __cplusplus) #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) && (a.real >= 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 /* Declarations */ #if CYTHON_CCOMPLEX && (1) && (!0 || __cplusplus) #ifdef __cplusplus static CYTHON_INLINE __pyx_t_long_double_complex __pyx_t_long_double_complex_from_parts(long double x, long double y) { return ::std::complex< long double >(x, y); } #else static CYTHON_INLINE __pyx_t_long_double_complex __pyx_t_long_double_complex_from_parts(long double x, long double y) { return x + y*(__pyx_t_long_double_complex)_Complex_I; } #endif #else static CYTHON_INLINE __pyx_t_long_double_complex __pyx_t_long_double_complex_from_parts(long double x, long double y) { __pyx_t_long_double_complex z; z.real = x; z.imag = y; return z; } #endif /* Arithmetic */ #if CYTHON_CCOMPLEX && (1) && (!0 || __cplusplus) #else static CYTHON_INLINE int __Pyx_c_eq_long__double(__pyx_t_long_double_complex a, __pyx_t_long_double_complex b) { return (a.real == b.real) && (a.imag == b.imag); } static CYTHON_INLINE __pyx_t_long_double_complex __Pyx_c_sum_long__double(__pyx_t_long_double_complex a, __pyx_t_long_double_complex b) { __pyx_t_long_double_complex z; z.real = a.real + b.real; z.imag = a.imag + b.imag; return z; } static CYTHON_INLINE __pyx_t_long_double_complex __Pyx_c_diff_long__double(__pyx_t_long_double_complex a, __pyx_t_long_double_complex b) { __pyx_t_long_double_complex z; z.real = a.real - b.real; z.imag = a.imag - b.imag; return z; } static CYTHON_INLINE __pyx_t_long_double_complex __Pyx_c_prod_long__double(__pyx_t_long_double_complex a, __pyx_t_long_double_complex b) { __pyx_t_long_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_long_double_complex __Pyx_c_quot_long__double(__pyx_t_long_double_complex a, __pyx_t_long_double_complex b) { if (b.imag == 0) { return __pyx_t_long_double_complex_from_parts(a.real / b.real, a.imag / b.real); } else if (fabsl(b.real) >= fabsl(b.imag)) { if (b.real == 0 && b.imag == 0) { return __pyx_t_long_double_complex_from_parts(a.real / b.real, a.imag / b.imag); } else { long double r = b.imag / b.real; long double s = (long double)(1.0) / (b.real + b.imag * r); return __pyx_t_long_double_complex_from_parts( (a.real + a.imag * r) * s, (a.imag - a.real * r) * s); } } else { long double r = b.real / b.imag; long double s = (long double)(1.0) / (b.imag + b.real * r); return __pyx_t_long_double_complex_from_parts( (a.real * r + a.imag) * s, (a.imag * r - a.real) * s); } } #else static CYTHON_INLINE __pyx_t_long_double_complex __Pyx_c_quot_long__double(__pyx_t_long_double_complex a, __pyx_t_long_double_complex b) { if (b.imag == 0) { return __pyx_t_long_double_complex_from_parts(a.real / b.real, a.imag / b.real); } else { long double denom = b.real * b.real + b.imag * b.imag; return __pyx_t_long_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_long_double_complex __Pyx_c_neg_long__double(__pyx_t_long_double_complex a) { __pyx_t_long_double_complex z; z.real = -a.real; z.imag = -a.imag; return z; } static CYTHON_INLINE int __Pyx_c_is_zero_long__double(__pyx_t_long_double_complex a) { return (a.real == 0) && (a.imag == 0); } static CYTHON_INLINE __pyx_t_long_double_complex __Pyx_c_conj_long__double(__pyx_t_long_double_complex a) { __pyx_t_long_double_complex z; z.real = a.real; z.imag = -a.imag; return z; } #if 1 static CYTHON_INLINE long double __Pyx_c_abs_long__double(__pyx_t_long_double_complex z) { #if !defined(HAVE_HYPOT) || defined(_MSC_VER) return sqrtl(z.real*z.real + z.imag*z.imag); #else return hypotl(z.real, z.imag); #endif } static CYTHON_INLINE __pyx_t_long_double_complex __Pyx_c_pow_long__double(__pyx_t_long_double_complex a, __pyx_t_long_double_complex b) { __pyx_t_long_double_complex z; long double r, lnr, theta, z_r, z_theta; if (b.imag == 0 && b.real == (int)b.real) { if (b.real < 0) { long 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_long__double(a, a); case 3: z = __Pyx_c_prod_long__double(a, a); return __Pyx_c_prod_long__double(z, a); case 4: z = __Pyx_c_prod_long__double(a, a); return __Pyx_c_prod_long__double(z, z); } } if (a.imag == 0) { if (a.real == 0) { return a; } else if ((b.imag == 0) && (a.real >= 0)) { z.real = powl(a.real, b.real); z.imag = 0; return z; } else if (a.real > 0) { r = a.real; theta = 0; } else { r = -a.real; theta = atan2l(0.0, -1.0); } } else { r = __Pyx_c_abs_long__double(a); theta = atan2l(a.imag, a.real); } lnr = logl(r); z_r = expl(lnr * b.real - theta * b.imag); z_theta = theta * b.real + lnr * b.imag; z.real = z_r * cosl(z_theta); z.imag = z_r * sinl(z_theta); return z; } #endif #endif /* 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; } /* 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_type *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_type *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) { __pyx_nonatomic_int_type old_acquisition_count; struct __pyx_memoryview_obj *memview = memslice->memview; if (unlikely(!memview || (PyObject *) memview == Py_None)) { return; } old_acquisition_count = __pyx_add_acquisition_count(memview); if (unlikely(old_acquisition_count <= 0)) { if (likely(old_acquisition_count == 0)) { if (have_gil) { Py_INCREF((PyObject *) memview); } else { PyGILState_STATE _gilstate = PyGILState_Ensure(); Py_INCREF((PyObject *) memview); PyGILState_Release(_gilstate); } } else { __pyx_fatalerror("Acquisition count is %d (line %d)", old_acquisition_count+1, lineno); } } } static CYTHON_INLINE void __Pyx_XCLEAR_MEMVIEW(__Pyx_memviewslice *memslice, int have_gil, int lineno) { __pyx_nonatomic_int_type old_acquisition_count; struct __pyx_memoryview_obj *memview = memslice->memview; if (unlikely(!memview || (PyObject *) memview == Py_None)) { memslice->memview = NULL; return; } old_acquisition_count = __pyx_sub_acquisition_count(memview); memslice->data = NULL; if (likely(old_acquisition_count > 1)) { memslice->memview = NULL; } else if (likely(old_acquisition_count == 1)) { if (have_gil) { Py_CLEAR(memslice->memview); } else { PyGILState_STATE _gilstate = PyGILState_Ensure(); Py_CLEAR(memslice->memview); PyGILState_Release(_gilstate); } } else { __pyx_fatalerror("Acquisition count is %d (line %d)", old_acquisition_count-1, lineno); } } /* 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 if (unlikely(__Pyx_PyLong_IsNeg(x))) { goto raise_neg_overflow; } else if (__Pyx_PyLong_IsCompact(x)) { __PYX_VERIFY_RETURN_INT(int, __Pyx_compact_upylong, __Pyx_PyLong_CompactValueUnsigned(x)) } else { const digit* digits = __Pyx_PyLong_Digits(x); assert(__Pyx_PyLong_DigitCount(x) > 1); switch (__Pyx_PyLong_DigitCount(x)) { 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 && PY_VERSION_HEX < 0x030C00A7 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 if (__Pyx_PyLong_IsCompact(x)) { __PYX_VERIFY_RETURN_INT(int, __Pyx_compact_pylong, __Pyx_PyLong_CompactValue(x)) } else { const digit* digits = __Pyx_PyLong_Digits(x); assert(__Pyx_PyLong_DigitCount(x) > 1); switch (__Pyx_PyLong_SignedDigitCount(x)) { 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 } } { 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 ret = -1; #if PY_VERSION_HEX < 0x030d0000 && !(CYTHON_COMPILING_IN_PYPY || CYTHON_COMPILING_IN_LIMITED_API) || defined(_PyLong_AsByteArray) int one = 1; int is_little = (int)*(unsigned char *)&one; unsigned char *bytes = (unsigned char *)&val; ret = _PyLong_AsByteArray((PyLongObject *)v, bytes, sizeof(val), is_little, !is_unsigned); #else PyObject *stepval = NULL, *mask = NULL, *shift = NULL; int bits, remaining_bits, is_negative = 0; long idigit; int chunk_size = (sizeof(long) < 8) ? 30 : 62; if (unlikely(!PyLong_CheckExact(v))) { PyObject *tmp = v; v = PyNumber_Long(v); assert(PyLong_CheckExact(v)); Py_DECREF(tmp); if (unlikely(!v)) return (int) -1; } #if CYTHON_COMPILING_IN_LIMITED_API && PY_VERSION_HEX < 0x030B0000 if (Py_SIZE(x) == 0) return (int) 0; is_negative = Py_SIZE(x) < 0; #else { int result = PyObject_RichCompareBool(x, Py_False, Py_LT); if (unlikely(result < 0)) return (int) -1; is_negative = result == 1; } #endif if (is_unsigned && unlikely(is_negative)) { goto raise_neg_overflow; } else if (is_negative) { stepval = PyNumber_Invert(v); if (unlikely(!stepval)) return (int) -1; } else { stepval = __Pyx_NewRef(v); } val = (int) 0; mask = PyLong_FromLong((1L << chunk_size) - 1); if (unlikely(!mask)) goto done; shift = PyLong_FromLong(chunk_size); if (unlikely(!shift)) goto done; for (bits = 0; bits < (int) sizeof(int) * 8 - chunk_size; bits += chunk_size) { PyObject *tmp, *digit; digit = PyNumber_And(stepval, mask); if (unlikely(!digit)) goto done; idigit = PyLong_AsLong(digit); Py_DECREF(digit); if (unlikely(idigit < 0)) goto done; tmp = PyNumber_Rshift(stepval, shift); if (unlikely(!tmp)) goto done; Py_DECREF(stepval); stepval = tmp; val |= ((int) idigit) << bits; #if CYTHON_COMPILING_IN_LIMITED_API && PY_VERSION_HEX < 0x030B0000 if (Py_SIZE(stepval) == 0) goto unpacking_done; #endif } idigit = PyLong_AsLong(stepval); if (unlikely(idigit < 0)) goto done; remaining_bits = ((int) sizeof(int) * 8) - bits - (is_unsigned ? 0 : 1); if (unlikely(idigit >= (1L << remaining_bits))) goto raise_overflow; val |= ((int) idigit) << bits; #if CYTHON_COMPILING_IN_LIMITED_API && PY_VERSION_HEX < 0x030B0000 unpacking_done: #endif if (!is_unsigned) { if (unlikely(val & (((int) 1) << (sizeof(int) * 8 - 1)))) goto raise_overflow; if (is_negative) val = ~val; } ret = 0; done: Py_XDECREF(shift); Py_XDECREF(mask); Py_XDECREF(stepval); #endif Py_DECREF(v); if (likely(!ret)) return val; } 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_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; #if !CYTHON_COMPILING_IN_LIMITED_API && PY_VERSION_HEX < 0x030d0000 return _PyLong_FromByteArray(bytes, sizeof(int), little, !is_unsigned); #else PyObject *from_bytes, *result = NULL; PyObject *py_bytes = NULL, *arg_tuple = NULL, *kwds = NULL, *order_str = NULL; from_bytes = PyObject_GetAttrString((PyObject*)&PyLong_Type, "from_bytes"); if (!from_bytes) return NULL; py_bytes = PyBytes_FromStringAndSize((char*)bytes, sizeof(int)); if (!py_bytes) goto limited_bad; order_str = PyUnicode_FromString(little ? "little" : "big"); if (!order_str) goto limited_bad; arg_tuple = PyTuple_Pack(2, py_bytes, order_str); if (!arg_tuple) goto limited_bad; if (!is_unsigned) { kwds = PyDict_New(); if (!kwds) goto limited_bad; if (PyDict_SetItemString(kwds, "signed", __Pyx_NewRef(Py_True))) goto limited_bad; } result = PyObject_Call(from_bytes, arg_tuple, kwds); limited_bad: Py_XDECREF(kwds); Py_XDECREF(arg_tuple); Py_XDECREF(order_str); Py_XDECREF(py_bytes); Py_XDECREF(from_bytes); return result; #endif } } /* CIntFromPy */ static CYTHON_INLINE uint8_t __Pyx_PyInt_As_uint8_t(PyObject *x) { #ifdef __Pyx_HAS_GCC_DIAGNOSTIC #pragma GCC diagnostic push #pragma GCC diagnostic ignored "-Wconversion" #endif const uint8_t neg_one = (uint8_t) -1, const_zero = (uint8_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(uint8_t) < sizeof(long))) { __PYX_VERIFY_RETURN_INT(uint8_t, long, PyInt_AS_LONG(x)) } else { long val = PyInt_AS_LONG(x); if (is_unsigned && unlikely(val < 0)) { goto raise_neg_overflow; } return (uint8_t) val; } } else #endif if (likely(PyLong_Check(x))) { if (is_unsigned) { #if CYTHON_USE_PYLONG_INTERNALS if (unlikely(__Pyx_PyLong_IsNeg(x))) { goto raise_neg_overflow; } else if (__Pyx_PyLong_IsCompact(x)) { __PYX_VERIFY_RETURN_INT(uint8_t, __Pyx_compact_upylong, __Pyx_PyLong_CompactValueUnsigned(x)) } else { const digit* digits = __Pyx_PyLong_Digits(x); assert(__Pyx_PyLong_DigitCount(x) > 1); switch (__Pyx_PyLong_DigitCount(x)) { case 2: if ((8 * sizeof(uint8_t) > 1 * PyLong_SHIFT)) { if ((8 * sizeof(unsigned long) > 2 * PyLong_SHIFT)) { __PYX_VERIFY_RETURN_INT(uint8_t, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) } else if ((8 * sizeof(uint8_t) >= 2 * PyLong_SHIFT)) { return (uint8_t) (((((uint8_t)digits[1]) << PyLong_SHIFT) | (uint8_t)digits[0])); } } break; case 3: if ((8 * sizeof(uint8_t) > 2 * PyLong_SHIFT)) { if ((8 * sizeof(unsigned long) > 3 * PyLong_SHIFT)) { __PYX_VERIFY_RETURN_INT(uint8_t, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) } else if ((8 * sizeof(uint8_t) >= 3 * PyLong_SHIFT)) { return (uint8_t) (((((((uint8_t)digits[2]) << PyLong_SHIFT) | (uint8_t)digits[1]) << PyLong_SHIFT) | (uint8_t)digits[0])); } } break; case 4: if ((8 * sizeof(uint8_t) > 3 * PyLong_SHIFT)) { if ((8 * sizeof(unsigned long) > 4 * PyLong_SHIFT)) { __PYX_VERIFY_RETURN_INT(uint8_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(uint8_t) >= 4 * PyLong_SHIFT)) { return (uint8_t) (((((((((uint8_t)digits[3]) << PyLong_SHIFT) | (uint8_t)digits[2]) << PyLong_SHIFT) | (uint8_t)digits[1]) << PyLong_SHIFT) | (uint8_t)digits[0])); } } break; } } #endif #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX < 0x030C00A7 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 (uint8_t) -1; if (unlikely(result == 1)) goto raise_neg_overflow; } #endif if ((sizeof(uint8_t) <= sizeof(unsigned long))) { __PYX_VERIFY_RETURN_INT_EXC(uint8_t, unsigned long, PyLong_AsUnsignedLong(x)) #ifdef HAVE_LONG_LONG } else if ((sizeof(uint8_t) <= sizeof(unsigned PY_LONG_LONG))) { __PYX_VERIFY_RETURN_INT_EXC(uint8_t, unsigned PY_LONG_LONG, PyLong_AsUnsignedLongLong(x)) #endif } } else { #if CYTHON_USE_PYLONG_INTERNALS if (__Pyx_PyLong_IsCompact(x)) { __PYX_VERIFY_RETURN_INT(uint8_t, __Pyx_compact_pylong, __Pyx_PyLong_CompactValue(x)) } else { const digit* digits = __Pyx_PyLong_Digits(x); assert(__Pyx_PyLong_DigitCount(x) > 1); switch (__Pyx_PyLong_SignedDigitCount(x)) { case -2: if ((8 * sizeof(uint8_t) - 1 > 1 * PyLong_SHIFT)) { if ((8 * sizeof(unsigned long) > 2 * PyLong_SHIFT)) { __PYX_VERIFY_RETURN_INT(uint8_t, long, -(long) (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) } else if ((8 * sizeof(uint8_t) - 1 > 2 * PyLong_SHIFT)) { return (uint8_t) (((uint8_t)-1)*(((((uint8_t)digits[1]) << PyLong_SHIFT) | (uint8_t)digits[0]))); } } break; case 2: if ((8 * sizeof(uint8_t) > 1 * PyLong_SHIFT)) { if ((8 * sizeof(unsigned long) > 2 * PyLong_SHIFT)) { __PYX_VERIFY_RETURN_INT(uint8_t, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) } else if ((8 * sizeof(uint8_t) - 1 > 2 * PyLong_SHIFT)) { return (uint8_t) ((((((uint8_t)digits[1]) << PyLong_SHIFT) | (uint8_t)digits[0]))); } } break; case -3: if ((8 * sizeof(uint8_t) - 1 > 2 * PyLong_SHIFT)) { if ((8 * sizeof(unsigned long) > 3 * PyLong_SHIFT)) { __PYX_VERIFY_RETURN_INT(uint8_t, long, -(long) (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) } else if ((8 * sizeof(uint8_t) - 1 > 3 * PyLong_SHIFT)) { return (uint8_t) (((uint8_t)-1)*(((((((uint8_t)digits[2]) << PyLong_SHIFT) | (uint8_t)digits[1]) << PyLong_SHIFT) | (uint8_t)digits[0]))); } } break; case 3: if ((8 * sizeof(uint8_t) > 2 * PyLong_SHIFT)) { if ((8 * sizeof(unsigned long) > 3 * PyLong_SHIFT)) { __PYX_VERIFY_RETURN_INT(uint8_t, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) } else if ((8 * sizeof(uint8_t) - 1 > 3 * PyLong_SHIFT)) { return (uint8_t) ((((((((uint8_t)digits[2]) << PyLong_SHIFT) | (uint8_t)digits[1]) << PyLong_SHIFT) | (uint8_t)digits[0]))); } } break; case -4: if ((8 * sizeof(uint8_t) - 1 > 3 * PyLong_SHIFT)) { if ((8 * sizeof(unsigned long) > 4 * PyLong_SHIFT)) { __PYX_VERIFY_RETURN_INT(uint8_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(uint8_t) - 1 > 4 * PyLong_SHIFT)) { return (uint8_t) (((uint8_t)-1)*(((((((((uint8_t)digits[3]) << PyLong_SHIFT) | (uint8_t)digits[2]) << PyLong_SHIFT) | (uint8_t)digits[1]) << PyLong_SHIFT) | (uint8_t)digits[0]))); } } break; case 4: if ((8 * sizeof(uint8_t) > 3 * PyLong_SHIFT)) { if ((8 * sizeof(unsigned long) > 4 * PyLong_SHIFT)) { __PYX_VERIFY_RETURN_INT(uint8_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(uint8_t) - 1 > 4 * PyLong_SHIFT)) { return (uint8_t) ((((((((((uint8_t)digits[3]) << PyLong_SHIFT) | (uint8_t)digits[2]) << PyLong_SHIFT) | (uint8_t)digits[1]) << PyLong_SHIFT) | (uint8_t)digits[0]))); } } break; } } #endif if ((sizeof(uint8_t) <= sizeof(long))) { __PYX_VERIFY_RETURN_INT_EXC(uint8_t, long, PyLong_AsLong(x)) #ifdef HAVE_LONG_LONG } else if ((sizeof(uint8_t) <= sizeof(PY_LONG_LONG))) { __PYX_VERIFY_RETURN_INT_EXC(uint8_t, PY_LONG_LONG, PyLong_AsLongLong(x)) #endif } } { uint8_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 ret = -1; #if PY_VERSION_HEX < 0x030d0000 && !(CYTHON_COMPILING_IN_PYPY || CYTHON_COMPILING_IN_LIMITED_API) || defined(_PyLong_AsByteArray) int one = 1; int is_little = (int)*(unsigned char *)&one; unsigned char *bytes = (unsigned char *)&val; ret = _PyLong_AsByteArray((PyLongObject *)v, bytes, sizeof(val), is_little, !is_unsigned); #else PyObject *stepval = NULL, *mask = NULL, *shift = NULL; int bits, remaining_bits, is_negative = 0; long idigit; int chunk_size = (sizeof(long) < 8) ? 30 : 62; if (unlikely(!PyLong_CheckExact(v))) { PyObject *tmp = v; v = PyNumber_Long(v); assert(PyLong_CheckExact(v)); Py_DECREF(tmp); if (unlikely(!v)) return (uint8_t) -1; } #if CYTHON_COMPILING_IN_LIMITED_API && PY_VERSION_HEX < 0x030B0000 if (Py_SIZE(x) == 0) return (uint8_t) 0; is_negative = Py_SIZE(x) < 0; #else { int result = PyObject_RichCompareBool(x, Py_False, Py_LT); if (unlikely(result < 0)) return (uint8_t) -1; is_negative = result == 1; } #endif if (is_unsigned && unlikely(is_negative)) { goto raise_neg_overflow; } else if (is_negative) { stepval = PyNumber_Invert(v); if (unlikely(!stepval)) return (uint8_t) -1; } else { stepval = __Pyx_NewRef(v); } val = (uint8_t) 0; mask = PyLong_FromLong((1L << chunk_size) - 1); if (unlikely(!mask)) goto done; shift = PyLong_FromLong(chunk_size); if (unlikely(!shift)) goto done; for (bits = 0; bits < (int) sizeof(uint8_t) * 8 - chunk_size; bits += chunk_size) { PyObject *tmp, *digit; digit = PyNumber_And(stepval, mask); if (unlikely(!digit)) goto done; idigit = PyLong_AsLong(digit); Py_DECREF(digit); if (unlikely(idigit < 0)) goto done; tmp = PyNumber_Rshift(stepval, shift); if (unlikely(!tmp)) goto done; Py_DECREF(stepval); stepval = tmp; val |= ((uint8_t) idigit) << bits; #if CYTHON_COMPILING_IN_LIMITED_API && PY_VERSION_HEX < 0x030B0000 if (Py_SIZE(stepval) == 0) goto unpacking_done; #endif } idigit = PyLong_AsLong(stepval); if (unlikely(idigit < 0)) goto done; remaining_bits = ((int) sizeof(uint8_t) * 8) - bits - (is_unsigned ? 0 : 1); if (unlikely(idigit >= (1L << remaining_bits))) goto raise_overflow; val |= ((uint8_t) idigit) << bits; #if CYTHON_COMPILING_IN_LIMITED_API && PY_VERSION_HEX < 0x030B0000 unpacking_done: #endif if (!is_unsigned) { if (unlikely(val & (((uint8_t) 1) << (sizeof(uint8_t) * 8 - 1)))) goto raise_overflow; if (is_negative) val = ~val; } ret = 0; done: Py_XDECREF(shift); Py_XDECREF(mask); Py_XDECREF(stepval); #endif Py_DECREF(v); if (likely(!ret)) return val; } return (uint8_t) -1; } } else { uint8_t val; PyObject *tmp = __Pyx_PyNumber_IntOrLong(x); if (!tmp) return (uint8_t) -1; val = __Pyx_PyInt_As_uint8_t(tmp); Py_DECREF(tmp); return val; } raise_overflow: PyErr_SetString(PyExc_OverflowError, "value too large to convert to uint8_t"); return (uint8_t) -1; raise_neg_overflow: PyErr_SetString(PyExc_OverflowError, "can't convert negative value to uint8_t"); return (uint8_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; #if !CYTHON_COMPILING_IN_LIMITED_API && PY_VERSION_HEX < 0x030d0000 return _PyLong_FromByteArray(bytes, sizeof(long), little, !is_unsigned); #else PyObject *from_bytes, *result = NULL; PyObject *py_bytes = NULL, *arg_tuple = NULL, *kwds = NULL, *order_str = NULL; from_bytes = PyObject_GetAttrString((PyObject*)&PyLong_Type, "from_bytes"); if (!from_bytes) return NULL; py_bytes = PyBytes_FromStringAndSize((char*)bytes, sizeof(long)); if (!py_bytes) goto limited_bad; order_str = PyUnicode_FromString(little ? "little" : "big"); if (!order_str) goto limited_bad; arg_tuple = PyTuple_Pack(2, py_bytes, order_str); if (!arg_tuple) goto limited_bad; if (!is_unsigned) { kwds = PyDict_New(); if (!kwds) goto limited_bad; if (PyDict_SetItemString(kwds, "signed", __Pyx_NewRef(Py_True))) goto limited_bad; } result = PyObject_Call(from_bytes, arg_tuple, kwds); limited_bad: Py_XDECREF(kwds); Py_XDECREF(arg_tuple); Py_XDECREF(order_str); Py_XDECREF(py_bytes); Py_XDECREF(from_bytes); return result; #endif } } /* 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 if (unlikely(__Pyx_PyLong_IsNeg(x))) { goto raise_neg_overflow; } else if (__Pyx_PyLong_IsCompact(x)) { __PYX_VERIFY_RETURN_INT(long, __Pyx_compact_upylong, __Pyx_PyLong_CompactValueUnsigned(x)) } else { const digit* digits = __Pyx_PyLong_Digits(x); assert(__Pyx_PyLong_DigitCount(x) > 1); switch (__Pyx_PyLong_DigitCount(x)) { 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 && PY_VERSION_HEX < 0x030C00A7 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 if (__Pyx_PyLong_IsCompact(x)) { __PYX_VERIFY_RETURN_INT(long, __Pyx_compact_pylong, __Pyx_PyLong_CompactValue(x)) } else { const digit* digits = __Pyx_PyLong_Digits(x); assert(__Pyx_PyLong_DigitCount(x) > 1); switch (__Pyx_PyLong_SignedDigitCount(x)) { 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 } } { 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 ret = -1; #if PY_VERSION_HEX < 0x030d0000 && !(CYTHON_COMPILING_IN_PYPY || CYTHON_COMPILING_IN_LIMITED_API) || defined(_PyLong_AsByteArray) int one = 1; int is_little = (int)*(unsigned char *)&one; unsigned char *bytes = (unsigned char *)&val; ret = _PyLong_AsByteArray((PyLongObject *)v, bytes, sizeof(val), is_little, !is_unsigned); #else PyObject *stepval = NULL, *mask = NULL, *shift = NULL; int bits, remaining_bits, is_negative = 0; long idigit; int chunk_size = (sizeof(long) < 8) ? 30 : 62; if (unlikely(!PyLong_CheckExact(v))) { PyObject *tmp = v; v = PyNumber_Long(v); assert(PyLong_CheckExact(v)); Py_DECREF(tmp); if (unlikely(!v)) return (long) -1; } #if CYTHON_COMPILING_IN_LIMITED_API && PY_VERSION_HEX < 0x030B0000 if (Py_SIZE(x) == 0) return (long) 0; is_negative = Py_SIZE(x) < 0; #else { int result = PyObject_RichCompareBool(x, Py_False, Py_LT); if (unlikely(result < 0)) return (long) -1; is_negative = result == 1; } #endif if (is_unsigned && unlikely(is_negative)) { goto raise_neg_overflow; } else if (is_negative) { stepval = PyNumber_Invert(v); if (unlikely(!stepval)) return (long) -1; } else { stepval = __Pyx_NewRef(v); } val = (long) 0; mask = PyLong_FromLong((1L << chunk_size) - 1); if (unlikely(!mask)) goto done; shift = PyLong_FromLong(chunk_size); if (unlikely(!shift)) goto done; for (bits = 0; bits < (int) sizeof(long) * 8 - chunk_size; bits += chunk_size) { PyObject *tmp, *digit; digit = PyNumber_And(stepval, mask); if (unlikely(!digit)) goto done; idigit = PyLong_AsLong(digit); Py_DECREF(digit); if (unlikely(idigit < 0)) goto done; tmp = PyNumber_Rshift(stepval, shift); if (unlikely(!tmp)) goto done; Py_DECREF(stepval); stepval = tmp; val |= ((long) idigit) << bits; #if CYTHON_COMPILING_IN_LIMITED_API && PY_VERSION_HEX < 0x030B0000 if (Py_SIZE(stepval) == 0) goto unpacking_done; #endif } idigit = PyLong_AsLong(stepval); if (unlikely(idigit < 0)) goto done; remaining_bits = ((int) sizeof(long) * 8) - bits - (is_unsigned ? 0 : 1); if (unlikely(idigit >= (1L << remaining_bits))) goto raise_overflow; val |= ((long) idigit) << bits; #if CYTHON_COMPILING_IN_LIMITED_API && PY_VERSION_HEX < 0x030B0000 unpacking_done: #endif if (!is_unsigned) { if (unlikely(val & (((long) 1) << (sizeof(long) * 8 - 1)))) goto raise_overflow; if (is_negative) val = ~val; } ret = 0; done: Py_XDECREF(shift); Py_XDECREF(mask); Py_XDECREF(stepval); #endif Py_DECREF(v); if (likely(!ret)) return val; } 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 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 if (unlikely(__Pyx_PyLong_IsNeg(x))) { goto raise_neg_overflow; } else if (__Pyx_PyLong_IsCompact(x)) { __PYX_VERIFY_RETURN_INT(char, __Pyx_compact_upylong, __Pyx_PyLong_CompactValueUnsigned(x)) } else { const digit* digits = __Pyx_PyLong_Digits(x); assert(__Pyx_PyLong_DigitCount(x) > 1); switch (__Pyx_PyLong_DigitCount(x)) { 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 && PY_VERSION_HEX < 0x030C00A7 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 if (__Pyx_PyLong_IsCompact(x)) { __PYX_VERIFY_RETURN_INT(char, __Pyx_compact_pylong, __Pyx_PyLong_CompactValue(x)) } else { const digit* digits = __Pyx_PyLong_Digits(x); assert(__Pyx_PyLong_DigitCount(x) > 1); switch (__Pyx_PyLong_SignedDigitCount(x)) { 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 } } { 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 ret = -1; #if PY_VERSION_HEX < 0x030d0000 && !(CYTHON_COMPILING_IN_PYPY || CYTHON_COMPILING_IN_LIMITED_API) || defined(_PyLong_AsByteArray) int one = 1; int is_little = (int)*(unsigned char *)&one; unsigned char *bytes = (unsigned char *)&val; ret = _PyLong_AsByteArray((PyLongObject *)v, bytes, sizeof(val), is_little, !is_unsigned); #else PyObject *stepval = NULL, *mask = NULL, *shift = NULL; int bits, remaining_bits, is_negative = 0; long idigit; int chunk_size = (sizeof(long) < 8) ? 30 : 62; if (unlikely(!PyLong_CheckExact(v))) { PyObject *tmp = v; v = PyNumber_Long(v); assert(PyLong_CheckExact(v)); Py_DECREF(tmp); if (unlikely(!v)) return (char) -1; } #if CYTHON_COMPILING_IN_LIMITED_API && PY_VERSION_HEX < 0x030B0000 if (Py_SIZE(x) == 0) return (char) 0; is_negative = Py_SIZE(x) < 0; #else { int result = PyObject_RichCompareBool(x, Py_False, Py_LT); if (unlikely(result < 0)) return (char) -1; is_negative = result == 1; } #endif if (is_unsigned && unlikely(is_negative)) { goto raise_neg_overflow; } else if (is_negative) { stepval = PyNumber_Invert(v); if (unlikely(!stepval)) return (char) -1; } else { stepval = __Pyx_NewRef(v); } val = (char) 0; mask = PyLong_FromLong((1L << chunk_size) - 1); if (unlikely(!mask)) goto done; shift = PyLong_FromLong(chunk_size); if (unlikely(!shift)) goto done; for (bits = 0; bits < (int) sizeof(char) * 8 - chunk_size; bits += chunk_size) { PyObject *tmp, *digit; digit = PyNumber_And(stepval, mask); if (unlikely(!digit)) goto done; idigit = PyLong_AsLong(digit); Py_DECREF(digit); if (unlikely(idigit < 0)) goto done; tmp = PyNumber_Rshift(stepval, shift); if (unlikely(!tmp)) goto done; Py_DECREF(stepval); stepval = tmp; val |= ((char) idigit) << bits; #if CYTHON_COMPILING_IN_LIMITED_API && PY_VERSION_HEX < 0x030B0000 if (Py_SIZE(stepval) == 0) goto unpacking_done; #endif } idigit = PyLong_AsLong(stepval); if (unlikely(idigit < 0)) goto done; remaining_bits = ((int) sizeof(char) * 8) - bits - (is_unsigned ? 0 : 1); if (unlikely(idigit >= (1L << remaining_bits))) goto raise_overflow; val |= ((char) idigit) << bits; #if CYTHON_COMPILING_IN_LIMITED_API && PY_VERSION_HEX < 0x030B0000 unpacking_done: #endif if (!is_unsigned) { if (unlikely(val & (((char) 1) << (sizeof(char) * 8 - 1)))) goto raise_overflow; if (is_negative) val = ~val; } ret = 0; done: Py_XDECREF(shift); Py_XDECREF(mask); Py_XDECREF(stepval); #endif Py_DECREF(v); if (likely(!ret)) return val; } 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; } /* FormatTypeName */ #if CYTHON_COMPILING_IN_LIMITED_API static __Pyx_TypeName __Pyx_PyType_GetName(PyTypeObject* tp) { PyObject *name = __Pyx_PyObject_GetAttrStr((PyObject *)tp, __pyx_n_s_name_2); if (unlikely(name == NULL) || unlikely(!PyUnicode_Check(name))) { PyErr_Clear(); Py_XDECREF(name); name = __Pyx_NewRef(__pyx_n_s__38); } return name; } #endif /* CStringEquals */ static CYTHON_INLINE int __Pyx_StrEq(const char *s1, const char *s2) { while (*s1 != '\0' && *s1 == *s2) { s1++; s2++; } return *s1 == *s2; } /* CheckBinaryVersion */ static unsigned long __Pyx_get_runtime_version(void) { #if __PYX_LIMITED_VERSION_HEX >= 0x030B00A4 return Py_Version & ~0xFFUL; #else const char* rt_version = Py_GetVersion(); unsigned long version = 0; unsigned long factor = 0x01000000UL; unsigned int digit = 0; int i = 0; while (factor) { while ('0' <= rt_version[i] && rt_version[i] <= '9') { digit = digit * 10 + (unsigned int) (rt_version[i] - '0'); ++i; } version += factor * digit; if (rt_version[i] != '.') break; digit = 0; factor >>= 8; ++i; } return version; #endif } static int __Pyx_check_binary_version(unsigned long ct_version, unsigned long rt_version, int allow_newer) { const unsigned long MAJOR_MINOR = 0xFFFF0000UL; if ((rt_version & MAJOR_MINOR) == (ct_version & MAJOR_MINOR)) return 0; if (likely(allow_newer && (rt_version & MAJOR_MINOR) > (ct_version & MAJOR_MINOR))) return 1; { char message[200]; PyOS_snprintf(message, sizeof(message), "compile time Python version %d.%d " "of module '%.100s' " "%s " "runtime version %d.%d", (int) (ct_version >> 24), (int) ((ct_version >> 16) & 0xFF), __Pyx_MODULE_NAME, (allow_newer) ? "was newer than" : "does not match", (int) (rt_version >> 24), (int) ((rt_version >> 16) & 0xFF) ); return PyErr_WarnEx(NULL, message, 1); } } /* FunctionImport */ #ifndef __PYX_HAVE_RT_ImportFunction_3_0_10 #define __PYX_HAVE_RT_ImportFunction_3_0_10 static int __Pyx_ImportFunction_3_0_10(PyObject *module, const char *funcname, void (**f)(void), const char *sig) { PyObject *d = 0; PyObject *cobj = 0; union { void (*fp)(void); void *p; } tmp; d = PyObject_GetAttrString(module, (char *)"__pyx_capi__"); if (!d) goto bad; cobj = PyDict_GetItemString(d, funcname); if (!cobj) { PyErr_Format(PyExc_ImportError, "%.200s does not export expected C function %.200s", PyModule_GetName(module), funcname); goto bad; } if (!PyCapsule_IsValid(cobj, sig)) { PyErr_Format(PyExc_TypeError, "C function %.200s.%.200s has wrong signature (expected %.500s, got %.500s)", PyModule_GetName(module), funcname, sig, PyCapsule_GetName(cobj)); goto bad; } tmp.p = PyCapsule_GetPointer(cobj, sig); *f = tmp.fp; if (!(*f)) goto bad; Py_DECREF(d); return 0; bad: Py_XDECREF(d); return -1; } #endif /* InitStrings */ #if PY_MAJOR_VERSION >= 3 static int __Pyx_InitString(__Pyx_StringTabEntry t, PyObject **str) { if (t.is_unicode | t.is_str) { if (t.intern) { *str = PyUnicode_InternFromString(t.s); } else if (t.encoding) { *str = PyUnicode_Decode(t.s, t.n - 1, t.encoding, NULL); } else { *str = PyUnicode_FromStringAndSize(t.s, t.n - 1); } } else { *str = PyBytes_FromStringAndSize(t.s, t.n - 1); } if (!*str) return -1; if (PyObject_Hash(*str) == -1) return -1; return 0; } #endif static int __Pyx_InitStrings(__Pyx_StringTabEntry *t) { while (t->p) { #if PY_MAJOR_VERSION >= 3 __Pyx_InitString(*t, t->p); #else 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); } if (!*t->p) return -1; if (PyObject_Hash(*t->p) == -1) return -1; #endif ++t; } return 0; } #include static CYTHON_INLINE Py_ssize_t __Pyx_ssize_strlen(const char *s) { size_t len = strlen(s); if (unlikely(len > (size_t) PY_SSIZE_T_MAX)) { PyErr_SetString(PyExc_OverflowError, "byte string is too long"); return -1; } return (Py_ssize_t) len; } static CYTHON_INLINE PyObject* __Pyx_PyUnicode_FromString(const char* c_str) { Py_ssize_t len = __Pyx_ssize_strlen(c_str); if (unlikely(len < 0)) return NULL; return __Pyx_PyUnicode_FromStringAndSize(c_str, len); } static CYTHON_INLINE PyObject* __Pyx_PyByteArray_FromString(const char* c_str) { Py_ssize_t len = __Pyx_ssize_strlen(c_str); if (unlikely(len < 0)) return NULL; return PyByteArray_FromStringAndSize(c_str, len); } 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 && !CYTHON_COMPILING_IN_LIMITED_API) || (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) { __Pyx_TypeName result_type_name = __Pyx_PyType_GetName(Py_TYPE(result)); #if PY_MAJOR_VERSION >= 3 if (PyLong_Check(result)) { if (PyErr_WarnFormat(PyExc_DeprecationWarning, 1, "__int__ returned non-int (type " __Pyx_FMT_TYPENAME "). " "The ability to return an instance of a strict subclass of int is deprecated, " "and may be removed in a future version of Python.", result_type_name)) { __Pyx_DECREF_TypeName(result_type_name); Py_DECREF(result); return NULL; } __Pyx_DECREF_TypeName(result_type_name); return result; } #endif PyErr_Format(PyExc_TypeError, "__%.4s__ returned non-%.4s (type " __Pyx_FMT_TYPENAME ")", type_name, type_name, result_type_name); __Pyx_DECREF_TypeName(result_type_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 if (likely(__Pyx_PyLong_IsCompact(b))) { return __Pyx_PyLong_CompactValue(b); } else { const digit* digits = __Pyx_PyLong_Digits(b); const Py_ssize_t size = __Pyx_PyLong_SignedDigitCount(b); 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); } /* #### Code section: utility_code_pragmas_end ### */ #ifdef _MSC_VER #pragma warning( pop ) #endif /* #### Code section: end ### */ #endif /* Py_PYTHON_H */ ././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1714685814.0 astroscrappy-1.2.0/astroscrappy/astroscrappy.pyx0000644000175100001770000007714414615003566021722 0ustar00runnerdocker# Licensed under a 3-clause BSD style license - see LICENSE.rst # cython: boundscheck=False, nonecheck=False, wraparound=False, language_level=3, cdivision=True """ Name : astroscrappy: The Speedy Cosmic Ray Annihilation Package in Python Author : Curtis McCully Date : October 2014 """ import numpy as np cimport numpy as np np.import_array() cimport cython from cython.parallel cimport parallel, prange from .utils import * from .utils.median_utils cimport cymedian from libc.stdint cimport uint8_t ctypedef uint8_t bool from libc.stdlib cimport malloc, free def detect_cosmics(indat, inmask=None, inbkg=None, invar=None, float sigclip=4.5, float sigfrac=0.3, float objlim=5.0, float gain=1.0, float readnoise=6.5, float satlevel=65536.0, int niter=4, sepmed=True, cleantype='meanmask', fsmode='median', psfmodel='gauss', float psffwhm=2.5, int psfsize=7, psfk=None, float psfbeta=4.765, verbose=False): """detect_cosmics(indat, inmask=None, inbkg=None, invar=None, sigclip=4.5, sigfrac=0.3, objlim=5.0, gain=1.0, readnoise=6.5, satlevel=65536.0, niter=4, sepmed=True, cleantype='meanmask', fsmode='median', psfmodel='gauss', psffwhm=2.5, psfsize=7, psfk=None, psfbeta=4.765, verbose=False)\n Detect cosmic rays in a numpy array. If you use this code, please cite the Zendo DOI: https://zenodo.org/record/1482019 Please cite the original paper which can be found at: http://www.astro.yale.edu/dokkum/lacosmic/ van Dokkum 2001, PASP, 113, 789, 1420 (article : http://adsabs.harvard.edu/abs/2001PASP..113.1420V) Parameters ---------- indat : float numpy array Input data array that will be used for cosmic ray detection. This should include the sky background (or a mean background level, added back in after sky subtraction), so that noise can be estimated correctly from the data values. This should be in units of "counts". inmask : boolean numpy array, optional Input bad pixel mask. Values of True will be ignored in the cosmic ray detection/cleaning process. Default: None. inbkg : float numpy array, optional A pre-determined background image, to be subtracted from ``indat`` before running the main detection algorithm. This is used primarily with spectroscopic data, to remove sky lines and the cross-section of an object continuum during iteration, "protecting" them from spurious rejection (see the above paper). This background is not removed from the final, cleaned output (`cleanarr`). This should be in units of "counts", the same units of indat. This inbkg should be free from cosmic rays. When estimating the cosmic-ray free noise of the image, we will treat ``inbkg`` as a constant Poisson contribution to the variance. invar : float numpy array, optional A pre-determined estimate of the data variance (ie. noise squared) in each pixel, generated by previous processing of ``indat``. If provided, this is used in place of an internal noise model based on ``indat``, ``gain`` and ``readnoise``. This still gets median filtered and cleaned internally, to estimate what the noise in each pixel *would* be in the absence of cosmic rays. This should be in units of "counts" squared. sigclip : float, optional Laplacian-to-noise limit for cosmic ray detection. Lower values will flag more pixels as cosmic rays. Default: 4.5. sigfrac : float, optional Fractional detection limit for neighboring pixels. For cosmic ray neighbor pixels, a lapacian-to-noise detection limit of sigfrac * sigclip will be used. Default: 0.3. objlim : float, optional Minimum contrast between Laplacian image and the fine structure image. Increase this value if cores of bright stars are flagged as cosmic rays. Default: 5.0. gain : float, optional Gain of the image (electrons / ADU). We always need to work in electrons for cosmic ray detection. Default: 1.0 readnoise : float, optional Read noise of the image (electrons). Used to generate the noise model of the image. Default: 6.5. satlevel : float, optional Saturation of level of the image (electrons). This value is used to detect saturated stars and pixels at or above this level are added to the mask. Default: 65536.0. niter : int, optional Number of iterations of the LA Cosmic algorithm to perform. Default: 4. sepmed : boolean, optional Use the separable median filter instead of the full median filter. The separable median is not identical to the full median filter, but they are approximately the same and the separable median filter is significantly faster and still detects cosmic rays well. Default: True cleantype : {'median', 'medmask', 'meanmask', 'idw'}, optional Set which clean algorithm is used:\n 'median': An umasked 5x5 median filter\n 'medmask': A masked 5x5 median filter\n 'meanmask': A masked 5x5 mean filter\n 'idw': A masked 5x5 inverse distance weighted interpolation\n Default: "meanmask". fsmode : {'median', 'convolve'}, optional Method to build the fine structure image:\n 'median': Use the median filter in the standard LA Cosmic algorithm 'convolve': Convolve the image with the psf kernel to calculate the fine structure image using a matched filter technique. Default: 'median'. psfmodel : {'gauss', 'gaussx', 'gaussy', 'moffat'}, optional Model to use to generate the psf kernel if fsmode == 'convolve' and psfk is None. The current choices are Gaussian and Moffat profiles. 'gauss' and 'moffat' produce circular PSF kernels. The 'gaussx' and 'gaussy' produce Gaussian kernels in the x and y directions respectively. Default: "gauss". psffwhm : float, optional Full Width Half Maximum of the PSF to use to generate the kernel. Default: 2.5. psfsize : int, optional Size of the kernel to calculate. Returned kernel will have size psfsize x psfsize. psfsize should be odd. Default: 7. psfk : float numpy array, optional PSF kernel array to use for the fine structure image if fsmode == 'convolve'. If None and fsmode == 'convolve', we calculate the psf kernel using 'psfmodel'. Default: None. psfbeta : float, optional Moffat beta parameter. Only used if fsmode=='convolve' and psfmodel=='moffat'. Default: 4.765. verbose : boolean, optional Print to the screen or not. Default: False. Returns ------- crmask : boolean numpy array The cosmic ray mask (boolean) array with values of True where there are cosmic ray detections. cleanarr : float numpy array The cleaned data array. Notes ----- To reproduce the most similar behavior to the original LA Cosmic (written in IRAF), set inmask = None, satlevel = np.inf, sepmed=False, cleantype='medmask', and fsmode='median'. The original IRAF version distinguishes between spectroscopic and imaging data. This version does not. For best results on spectra, we recommend that you include an estimate of the background. One can generally obtain this by fitting columns with a smooth function. To efficiently identify cosmic rays, LA Cosmic and therefore astroscrappy estimates the cosmic ray free noise by smoothing the variance using a median filter. To minimize false positives on bright sky lines, if ``inbkg`` is provided, we do not smooth the variance contribution from the provided background. We only smooth the variance that is in addition to the Poisson contribution from the background so that we do not underestimate the noise (and therefore run the risk of flagging false positives) near narrow, bright sky lines. """ # Grab the sizes of the input array cdef int nx = indat.shape[1] cdef int ny = indat.shape[0] # Tell the compiler about the loop indices so it can optimize them. cdef int i, j = 0 # Make a copy of the data as the cleanarr that we work on # This guarantees that that the data will be contiguous and makes sure we # don't edit the input data. cleanarr = np.empty((ny, nx), dtype=np.float32, order='C') # Set the initial values to those of the data array # Multiply by the gain; the statistics only work properly with electrons. cleanarr[:, :] = indat[:, :] * gain if inbkg is not None: bkg = np.empty((ny, nx), dtype=np.float32, order='C') bkg[:, :] = inbkg[:, :] * gain # Setup the mask if inmask is None: # By default don't mask anything mask = np.zeros((ny, nx), dtype=np.uint8, order='C') else: # Make a copy of the input mask mask = np.empty((ny, nx), dtype=np.uint8, order='C') mask[:, :] = inmask[:, :] # Copy any noise estimates so we can clean them like the data, otherwise # use the main data array instead. if invar is not None and inbkg is not None: clean_var = invar * (gain * gain) - bkg elif invar is not None and inbkg is None: clean_var = invar * (gain * gain) elif invar is None and inbkg is not None: clean_var = cleanarr - bkg + readnoise * readnoise else: clean_var = cleanarr + readnoise * readnoise # Find the saturated stars and add them to the mask update_mask(np.asarray(cleanarr), np.asarray(mask), satlevel, sepmed) # Subtract the input sky model, if applicable. if inbkg is not None: cleanarr -= bkg # Find the unmasked pixels to calculate the sky. gooddata = np.zeros(int(nx * ny - np.asarray(mask).sum()), dtype=np.float32, order='c') igoodpix = 0 gooddata[:] = cleanarr[np.logical_not(mask)] # Get the default background level for large cosmic rays. background_level = median(gooddata, len(gooddata)) goodvar = np.empty_like(gooddata, order='c') goodvar[:] = clean_var[np.logical_not(mask)] background_var_level = median(goodvar, len(goodvar)) del goodvar del gooddata # Set up the psf kernel if necessary. if psfk is None and fsmode == 'convolve': # calculate the psf kernel psfk if psfmodel == 'gauss': psfk = gausskernel(psffwhm, psfsize) elif psfmodel == 'gaussx': psfk = gaussxkernel(psffwhm, psfsize) elif psfmodel == 'gaussy': psfk = gaussykernel(psffwhm, psfsize) elif psfmodel == 'moffat': psfk = moffatkernel(psffwhm, psfbeta, psfsize) else: raise ValueError('Please choose a supported PSF model.') # Reverse the psf kernel as that is what we use in the convolution throughout psfk[:, :] = psfk[::-1, ::-1] # Define a cosmic ray mask # This is what will be returned at the end crmask = np.zeros((ny, nx), dtype=np.uint8, order='C') # Calculate the detection limit for neighbor pixels cdef float sigcliplow = sigfrac * sigclip # Run lacosmic for up to maxiter iterations # We stop if no more cosmic ray pixels are found (quite rare) if verbose: print("Starting {} L.A.Cosmic iterations".format(niter)) for i in range(niter): if verbose: print("Iteration {}:".format(i + 1)) # Detect the cosmic rays # We subsample, convolve, clip negative values, # and rebin to original size subsam = subsample(cleanarr) conved = laplaceconvolve(subsam) del subsam conved[conved < 0] = 0.0 # This is called L+ in the original LA Cosmic/cosmics.py s = rebin(conved) del conved # Build a noise map, to compare the laplacian to, based on the input # data or (if supplied) input variance. If variance is used, it still # gets filtered, since we can best identify cosmic rays using what the # noise in a pixel *should* be, rather than what it actually is after # a cosmic ray hit. if sepmed: m5 = sepmedfilt7(clean_var) else: m5 = medfilt5(clean_var) # Here we add back in the background to get the full variance. m5 here is effectively the CR free variance if inbkg is not None: m5 += bkg # Clip noise so that we can take a square root m5[m5 < 0.00001] = 0.00001 noise = np.sqrt(m5) del m5 # Laplacian signal to noise ratio : s /= 2.0 * noise # the 2.0 is from the 2x2 subsampling and is denoted f_s in the original paper # This s is called sigmap in the original lacosmic.cl if sepmed: sp = sepmedfilt7(s) else: sp = medfilt5(s) # Remove the large structures (s prime) : sp = s - sp del s # Find the candidate cosmic rays goodpix = np.logical_not(mask) cosmics = np.logical_and(sp > sigclip, goodpix) # Build the fine structure image : # TODO: we can gain a reasonable performance boost if we only calculate the fine structure stuff for cosmic # pixels instead of the whole image if fsmode == 'convolve': # Use a match filter, the (reversed) psf convolved with the image / variance f = convolve(cleanarr / noise / noise, psfk) # Normalize by the sum of the weights to get the flux of the source assuming it was actually a psf. # This will pull the value of pixels that do not look like psfs (e.g. CRs) down. f = f / convolve(1.0 / noise / noise, psfk) elif fsmode == 'median': if sepmed: f = sepmedfilt5(cleanarr) else: f = medfilt3(cleanarr) else: raise ValueError('Please choose a valid fine structure mode.') if sepmed: m7 = sepmedfilt9(f) else: m7 = medfilt7(f) # Note that original paper compares L+ / Fine Structure Image < threshold. # The original code and therefore we compare S' / Fine Structure Image < threshold. # As such, we scale the fine structure image by the noise here so it is in the same units as S'. f = (f - m7) / noise # Clip f as we will divide by f. Similar to the IRAF version. f[f < 0.01] = 0.01 del m7 del noise # S' / F is still not exactly what is in the paper as we have subtracted the "sampling flux" from S # via the median filter. This should be an optimization because we have removed the smooth component # and are therefore comparing the candidate "CR flux" only. cosmics = np.logical_and(cosmics, (sp / f) > objlim) del f # What follows is a special treatment for neighbors, with more relaxed # constraints. # We grow these cosmics a first time to determine the immediate # neighborhood. cosmics = dilate3(cosmics) cosmics = np.logical_and(cosmics, goodpix) # From this grown set, we keep those that have sp > sigmaclip # Note that the only new pixels that should be added here are ones that were rejected by the # objlim test. As they are neighbors to true CRs, we take that as a prior that CR probability # of the neighboring pixel is enhanced. cosmics = np.logical_and(sp > sigclip, cosmics) # Now we repeat this procedure, but lower the detection limit to siglow cosmics = dilate3(cosmics) cosmics = np.logical_and(cosmics, goodpix) del goodpix cosmics = np.logical_and(sp > sigcliplow, cosmics) del sp # Our CR counter numcr = cosmics.sum() # Update the crmask with the cosmics we have found crmask[:, :] = np.logical_or(crmask, cosmics)[:, :] del cosmics if verbose: print("{} cosmic pixels this iteration".format(numcr)) # If we didn't find anything, we're done. if numcr == 0: break # otherwise clean the image and iterate if cleantype == 'median': # Unmasked median filter clean_median(cleanarr, crmask, nx, ny) clean_median(clean_var, crmask, nx, ny) # Masked mean filter elif cleantype == 'meanmask': clean_meanmask(cleanarr, crmask, mask, nx, ny, background_level) clean_meanmask(clean_var, crmask, mask, nx, ny, background_var_level) # Masked median filter elif cleantype == 'medmask': clean_medmask(cleanarr, crmask, mask, nx, ny, background_level) clean_medmask(clean_var, crmask, mask, nx, ny, background_var_level) # Inverse distance weighted interpolation elif cleantype == 'idw': clean_idwinterp(cleanarr, crmask, mask, nx, ny, background_level) clean_idwinterp(clean_var, crmask, mask, nx, ny, background_var_level) else: raise ValueError("""cleantype must be one of the following values: [median, meanmask, medmask, idw]""") # Restore the sky background if needed. if inbkg is not None: cleanarr += bkg cleanarr /= gain return crmask.astype(np.bool_), cleanarr def update_mask(np.ndarray[np.float32_t, ndim=2, mode='c', cast=True] data, np.ndarray[np.uint8_t, ndim=2, mode='c', cast=True] mask, float satlevel, bool sepmed): """update_mask(data, mask, satlevel, sepmed)\n Find staturated stars and puts them in the mask. This can then be used to avoid these regions in cosmic detection and cleaning procedures. The median filter is used to find large symmetric regions of saturated pixels (i.e. saturated stars). Parameters ---------- data : float numpy array The data array in which we look for saturated stars. mask : boolean numpy array Bad pixel mask. This mask will be dilated using dilate3 and then combined with the saturated star mask. satlevel : float Saturation level of the image. This value can be lowered if the cores of bright (saturated) stars are not being masked. sepmed : boolean Use the separable median or not. The separable median is not identical to the full median filter, but they are approximately the same and the separable median filter is significantly faster. """ # Find all of the saturated pixels satpixels = data >= satlevel # Use the median filter to estimate the large scale structure if sepmed: m5 = sepmedfilt7(data) else: m5 = medfilt5(data) # Use the median filtered image to find the cores of saturated stars # The 10 here is arbitray. Malte Tewes uses 2.0 in cosmics.py, but I # wanted to get more of the cores of saturated stars. satpixels = np.logical_and(satpixels, m5 > (satlevel / 10.0)) # Grow the input mask by one pixel to make sure we cover bad pixels grow_mask = dilate3(mask) # Dilate the saturated star mask to remove edge effects in the mask dilsatpixels = dilate5(satpixels, 2) del satpixels # Combine the saturated pixels with the given input mask # Note, we work on the mask pixels in place mask[:, :] = np.logical_or(dilsatpixels, grow_mask)[:, :] del grow_mask cdef void clean_meanmask(float[:, ::1] cleanarr, bool[:, ::1] crmask, bool[:, ::1] mask, int nx, int ny, float background_level): """clean_meanmask(cleanarr, crmask, mask, nx, ny, background_level)\n Clean the bad pixels in cleanarr using a 5x5 masked mean filter. Parameters ---------- cleanarr : float numpy array The array to be cleaned. crmask : boolean numpy array Cosmic ray mask. Pixels with a value of True in this mask will be cleaned. mask : boolean numpy array Bad pixel mask. Values of True indicate bad pixels. nx : int Size of cleanarr in the x-direction. Note cleanarr has dimensions ny x nx. ny : int Size of cleanarr in the y-direction. Note cleanarr has dimensions ny x nx. background_level : float Average value of the background. This value will be used if there are no good pixels in a 5x5 region. """ # Go through all of the pixels, ignore the borders cdef int i, j, k, l, numpix cdef float s cdef bool badpix with nogil, parallel(): # For each pixel for j in prange(2, ny - 2): for i in range(2, nx - 2): # if the pixel is in the crmask if crmask[j, i]: numpix = 0 s = 0.0 # sum the 25 pixels around the pixel # ignoring any pixels that are masked for l in range(-2, 3): for k in range(-2, 3): badpix = crmask[j + l, i + k] badpix = badpix or mask[j + l, i + k] if not badpix: s = s + cleanarr[j + l, i + k] numpix = numpix + 1 # if the pixels count is 0 # then put in the background of the image if numpix == 0: s = background_level else: # else take the mean s = s / float(numpix) cleanarr[j, i] = s cdef void clean_median(float[:, ::1] cleanarr, bool[:, ::1] crmask, int nx, int ny): """clean_medmask(cleanarr, crmask, mask, nx, ny, background_level)\n Clean the bad pixels in cleanarr using a 5x5 masked median filter. Parameters ---------- cleanarr : float numpy array The array to be cleaned. crmask : boolean numpy array Cosmic ray mask. Pixels with a value of True in this mask will be cleaned. nx : int size of cleanarr in the x-direction. Note cleanarr has dimensions ny x nx. ny : int size of cleanarr in the y-direction. Note cleanarr has dimensions ny x nx. """ # Go through all of the pixels, ignore the borders cdef int k, l, i, j, counter cdef float * medarr # For each pixel with nogil, parallel(): medarr = < float * > malloc(25 * sizeof(float)) for j in prange(2, ny - 2): for i in range(2, nx - 2): # if the pixel is in the crmask if crmask[j, i]: # median the 25 pixels around the pixel counter = 0 for l in range(-2, 3): for k in range(-2, 3): medarr[counter] = cleanarr[j + l, i + k] counter =+ 1 cleanarr[j, i] = cymedian(medarr, 25) free(medarr) cdef void clean_medmask(float[:, ::1] cleanarr, bool[:, ::1] crmask, bool[:, ::1] mask, int nx, int ny, float background_level): """clean_medmask(cleanarr, crmask, mask, nx, ny, background_level)\n Clean the bad pixels in cleanarr using a 5x5 masked median filter. Parameters ---------- cleanarr : float numpy array The array to be cleaned. crmask : boolean numpy array Cosmic ray mask. Pixels with a value of True in this mask will be cleaned. mask : boolean numpy array Bad pixel mask. Values of True indicate bad pixels. nx : int size of cleanarr in the x-direction. Note cleanarr has dimensions ny x nx. ny : int size of cleanarr in the y-direction. Note cleanarr has dimensions ny x nx. background_level : float Average value of the background. This value will be used if there are no good pixels in a 5x5 region. """ # Go through all of the pixels, ignore the borders cdef int k, l, i, j, numpix cdef float * medarr cdef bool badpixel # For each pixel with nogil, parallel(): medarr = < float * > malloc(25 * sizeof(float)) for j in prange(2, ny - 2): for i in range(2, nx - 2): # if the pixel is in the crmask if crmask[j, i]: numpix = 0 # median the 25 pixels around the pixel ignoring # any pixels that are masked for l in range(-2, 3): for k in range(-2, 3): badpixel = crmask[j + l, i + k] badpixel = badpixel or mask[j + l, i + k] if not badpixel: medarr[numpix] = cleanarr[j + l, i + k] numpix = numpix + 1 # if the pixels count is 0 then put in the background # of the image if numpix == 0: cleanarr[j, i] = background_level else: # else take the median cleanarr[j, i] = cymedian(medarr, numpix) free(medarr) cdef void clean_idwinterp(float[:, ::1] cleanarr, bool[:, ::1] crmask, bool[:, ::1] mask, int nx, int ny, float background_level): """clean_idwinterp(cleanarr, crmask, mask, nx, ny, background_level)\n Clean the bad pixels in cleanarr using a 5x5 using inverse distance weighted interpolation. Parameters ---------- cleanarr : float numpy array The array to be cleaned. crmask : boolean numpy array Cosmic ray mask. Pixels with a value of True in this mask will be cleaned. mask : boolean numpy array Bad pixel mask. Values of True indicate bad pixels. nx : int Size of cleanarr in the x-direction (int). Note cleanarr has dimensions ny x nx. ny : int Size of cleanarr in the y-direction (int). Note cleanarr has dimensions ny x nx. background_level : float Average value of the background. This value will be used if there are no good pixels in a 5x5 region. """ # Go through all of the pixels, ignore the borders cdef int i, j, k, l cdef float f11, f12, f21, f22 = background_level cdef int x1, x2, y1, y2 weightsarr = np.array([[0.35355339, 0.4472136, 0.5, 0.4472136, 0.35355339], [0.4472136, 0.70710678, 1., 0.70710678, 0.4472136], [0.5, 1., 0., 1., 0.5], [0.4472136, 0.70710678, 1., 0.70710678, 0.4472136], [0.35355339, 0.4472136, 0.5, 0.4472136, 0.35355339]], dtype=np.float32) cdef float[:, ::1] weights = weightsarr cdef float wsum cdef float val cdef int x, y # For each pixel with nogil, parallel(): for j in prange(2, ny - 2): for i in range(2, nx - 2): # if the pixel is in the crmask if crmask[j, i]: wsum = 0.0 val = 0.0 for l in range(-2, 3): y = j + l for k in range(-2, 3): x = i + k if not (crmask[y, x] or mask[y, x]): val = val + weights[l+2, k+2] * cleanarr[y, x] wsum = wsum + weights[l+2, k+2] if wsum < 1e-6: cleanarr[j, i] = background_level else: cleanarr[j, i] = val / wsum def gausskernel(float psffwhm, int kernsize): """gausskernel(psffwhm, kernsize)\n Calculate a circular Gaussian psf kernel. Parameters ---------- psffwhm : float Full Width Half Maximum of the PSF to use to generate the kernel. kernsize : int Size of the kernel to calculate. kernsize should be odd. Returned kernel will have size kernsize x kernsize. Returns ------- kernel : float numpy array Gaussian PSF kernel with size kernsize x kernsize. """ kernel = np.zeros((kernsize, kernsize), dtype=np.float32) # Make a grid of x and y values x = np.tile(np.arange(kernsize) - kernsize / 2, (kernsize, 1)) y = x.transpose().copy() # Calculate the offset, r r2 = x * x + y * y # Calculate the kernel sigma2 = psffwhm * psffwhm / 2.35482 / 2.35482 kernel[:, :] = np.exp(-0.5 * r2 / sigma2)[:, :] # Normalize the kernel kernel /= kernel.sum() return kernel def gaussxkernel(float psffwhm, int kernsize): """gaussxkernel(psffwhm, kernsize)\n Calculate a Gaussian kernel in the x-direction. This can be used for spectroscopic data. Parameters ---------- psffwhm : float Full Width Half Maximum of the PSF to use to generate the kernel. kernsize : int Size of the kernel to calculate. kernsize should be odd. Returned kernel will have size kernsize x kernsize. Returns ------- kernel : float numpy array Gaussian(x) kernel with size kernsize x kernsize. """ kernel = np.zeros((kernsize, kernsize), dtype=np.float32) # Make a grid of x and y values x = np.tile(np.arange(kernsize) - kernsize / 2, (kernsize, 1)) # Calculate the kernel sigma2 = psffwhm * psffwhm / 2.35482 / 2.35482 kernel[:, :] = np.exp(-0.5 * x * x / sigma2)[:, :] # Normalize the kernel kernel /= kernel.sum() return kernel def gaussykernel(float psffwhm, int kernsize): """gaussykernel(psffwhm, kernsize)\n Calculate a Gaussian kernel in the y-direction. This can be used for spectroscopic data. Parameters ---------- psffwhm : float Full Width Half Maximum of the PSF to use to generate the kernel. kernsize : int Size of the kernel to calculate. kernsize should be odd. Returned kernel will have size kernsize x kernsize. Returns ------- kernel : float numpy array Gaussian(y) kernel with size kernsize x kernsize. """ kernel = np.zeros((kernsize, kernsize), dtype=np.float32) # Make a grid of x and y values x = np.tile(np.arange(kernsize) - kernsize / 2, (kernsize, 1)) y = x.transpose().copy() # Calculate the kernel sigma2 = psffwhm * psffwhm / 2.35482 / 2.35482 kernel[:, :] = np.exp(-0.5 * y * y / sigma2)[:, :] # Normalize the kernel kernel /= kernel.sum() return kernel cdef moffatkernel(float psffwhm, float beta, int kernsize): """moffatkernel(psffwhm, beta, kernsize)\n Calculate a Moffat psf kernel. Parameters ---------- psffwhm : float Full Width Half Maximum of the PSF to use to generate the kernel. beta : float Moffat beta parameter kernsize : int Size of the kernel to calculate. Returned kernel will have size kernsize x kernsize. kernsize should be odd. Returns ------- kernel : float numpy array Moffat kernel with size kernsize x kernsize. """ kernel = np.zeros((kernsize, kernsize), dtype=np.float32) # Make a grid of x and y values x = np.tile(np.arange(kernsize) - kernsize / 2, (kernsize, 1)) y = x.transpose().copy() # Calculate the offset r r = np.sqrt(x * x + y * y) # Calculate the kernel hwhm = psffwhm / 2.0 alpha = hwhm / np.sqrt(np.power(2.0, (1.0 / beta)) - 1.0) kernel[:, :] = (np.power(1.0 + (r * r / alpha / alpha), -1.0 * beta))[:, :] # Normalize the kernel. kernel /= kernel.sum() return kernel ././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1714685814.0 astroscrappy-1.2.0/astroscrappy/conftest.py0000644000175100001770000000364514615003566020620 0ustar00runnerdocker# This file is used to configure the behavior of pytest when using the Astropy # test infrastructure. It needs to live inside the package in order for it to # get picked up when running the tests inside an interpreter using # packagename.test import os from astropy.version import version as astropy_version # For Astropy 3.0 and later, we can use the standalone pytest plugin if astropy_version < '3.0': from astropy.tests.pytest_plugins import * # noqa del pytest_report_header ASTROPY_HEADER = True else: try: from pytest_astropy_header.display import PYTEST_HEADER_MODULES, TESTED_VERSIONS ASTROPY_HEADER = True except ImportError: ASTROPY_HEADER = False def pytest_configure(config): if ASTROPY_HEADER: config.option.astropy_header = True # Customize the following lines to add/remove entries from the list of # packages for which version numbers are displayed when running the tests. PYTEST_HEADER_MODULES.pop('Pandas', None) PYTEST_HEADER_MODULES['scikit-image'] = 'skimage' from . import __version__ packagename = os.path.basename(os.path.dirname(__file__)) TESTED_VERSIONS[packagename] = __version__ # Uncomment the last two lines in this block to treat all DeprecationWarnings as # exceptions. For Astropy v2.0 or later, there are 2 additional keywords, # as follow (although default should work for most cases). # To ignore some packages that produce deprecation warnings on import # (in addition to 'compiler', 'scipy', 'pygments', 'ipykernel', and # 'setuptools'), add: # modules_to_ignore_on_import=['module_1', 'module_2'] # To ignore some specific deprecation warning messages for Python version # MAJOR.MINOR or later, add: # warnings_to_ignore_by_pyver={(MAJOR, MINOR): ['Message to ignore']} # from astropy.tests.helper import enable_deprecations_as_exceptions # noqa # enable_deprecations_as_exceptions() ././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1714685814.0 astroscrappy-1.2.0/astroscrappy/setup_package.py0000644000175100001770000000065314615003566021602 0ustar00runnerdockerimport os from numpy import get_include from setuptools import Extension ROOT = os.path.relpath(os.path.dirname(__file__)) def get_extensions(): sources = [os.path.join(ROOT, "astroscrappy.pyx")] ext = Extension( name="astroscrappy.astroscrappy", define_macros=[("NPY_NO_DEPRECATED_API", "NPY_1_7_API_VERSION")], include_dirs=[get_include()], sources=sources, ) return [ext] ././@PaxHeader0000000000000000000000000000003400000000000010212 xustar0028 mtime=1714685833.3654385 astroscrappy-1.2.0/astroscrappy/tests/0000755000175100001770000000000014615003611017542 5ustar00runnerdocker././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1714685814.0 astroscrappy-1.2.0/astroscrappy/tests/__init__.py0000644000175100001770000000015414615003566021664 0ustar00runnerdocker# Licensed under a 3-clause BSD style license - see LICENSE.rst """ This module contains package tests. """ ././@PaxHeader0000000000000000000000000000003400000000000010212 xustar0028 mtime=1714685833.3654385 astroscrappy-1.2.0/astroscrappy/tests/data/0000755000175100001770000000000014615003611020453 5ustar00runnerdocker././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1714685814.0 astroscrappy-1.2.0/astroscrappy/tests/data/gmos.fits0000644000175100001770000136730014615003566022332 0ustar00runnerdockerSIMPLE = T / conforms to FITS standard BITPIX = 8 / array data type NAXIS = 0 / number of array dimensions EXTEND = T COMMENT FITS (Flexible Image Transport System) format is defined in 'AstronomyCOMMENT and Astrophysics', volume 376, page 359; bibcode: 2001A&A...376..359H INSTRUME= 'GMOS-S ' / Instrument used to acquire data OBJECT = 'LTT7379 ' / Object Name OBSTYPE = 'OBJECT ' / Observation type OBSCLASS= 'partnerCal' / Observe class GEMPRGID= 'GS-2019B-Q-305' / Gemini programme ID OBSID = 'GS-2019B-Q-305-7' / Observation ID / Data label DATALAB = 'GS-2019B-Q-305-7-004' / DHS data label OBSERVER= 'J. Chavez' / Observer OBSERVAT= 'Gemini-South' / Name of telescope (Gemini-North|Gemini-South) TELESCOP= 'Gemini-South' / Gemini-North PARALLAX= 0. / Parallax of Target RADVEL = 0. / Heliocentric Radial Velocity EPOCH = 2000. / Epoch for Target coordinates EQUINOX = 2000. / Equinox of coordinate system TRKEQUIN= 2000. / Tracking equinox SSA = 'P. Candia' / SSA RA = 279.108125 / Right Ascension DEC = -44.31025 / Declination of Target ELEVATIO= 66.91005 / Current Elevation AZIMUTH = 133.776055555556 / Current Azimuth CRPA = 0.49316948972528 / Current Cass Rotator Position Angle HA = '-01:33:23.08' / Telescope hour angle LT = '21:42:26.9' / Local time at start of observation TRKFRAME= 'FK5 ' / Tracking co-ordinate DECTRACK= 0. / Differential tracking rate Dec TRKEPOCH= 58703.021628 / Differential tracking reference epoch RATRACK = 0. / Differential tracking rate RA FRAME = 'FK5 ' / Target coordinate system PMDEC = -0.1615 / Proper Motion in Declination PMRA = -0.01603 / Proper Motion in RA WAVELENG= 7400. / Effective Target Wavelength RAWIQ = 'Any ' / Raw Image Quality RAWCC = '70-percentile' / Raw Cloud Cover RAWWV = 'UNKNOWN ' / Raw Water Vapour/Transparency RAWBG = 'UNKNOWN ' / Raw Background RAWPIREQ= 'YES ' / PI Requirements Met RAWGEMQA= 'USABLE ' / Gemini Quality Assessment CGUIDMOD= 'Basic ' / Driving mode for carousel UT = '00:42:27.4' / UT at observation start DATE = '2019-08-08' / UT Date of observation (YYYY-MM-DD) M2BAFFLE= 'VISIBLE ' / Position of M2 baffle M2CENBAF= 'CLOSED ' / Position of M2 central hole baffle ST = '17:04:28.7' / Sidereal time at the start of the exposure XOFFSET = 0.15432377504409 / Telescope offset in x in arcsec YOFFSET = 0.9061870598354 / Telescope offset in y in arcsec POFFSET = -0.156000000459329 / Telescope offset in p in arcsec QOFFSET = -0.905900002656847 / Telescope offset in q in arcsec RAOFFSET= -0.706532415359935 / Telescope offset in RA in arcsec DECOFFSE= 0.588049964716129 / Telescope offset in DEC in arcsec RATRGOFF= 0. / Target offset in RA in arcsec DECTRGOF= 0. / Target offset in DEC in arcsec PA = 120. / Sky Position Angle at start of exposure IAA = 359.894 / Instrument Alignment Angle SFRT2 = -0.417 / Science fold rotation angle (degrees) SFTILT = 44.94 / Science fold tilt angle (degrees) SFLINEAR= -3. / Science fold linear position (mm) AOFOLD = 'park-pos.' / AO Pick-Off Mirror Position PWFS1_ST= 'parked ' / PWFS1 probe state (frozen,guiding,parked) PWFS2_ST= 'parked ' / PWFS2 probe state (frozen,guiding,parked) OIWFS_ST= 'guiding ' / OIWFS probe state (frozen,guiding,parked) AOWFS_ST= 'parked ' / AOWFS probe state (frozen,guiding,parked) SCIBAND = 3 / Science Ranking Band REQIQ = 'Any ' / Requested Image Quality REQCC = 'Any ' / Requested Cloud Cover REQBG = 'Any ' / Requested Background REQWV = 'Any ' / Requested Water Vapour NUMREQTW= 0 / Number of Requested Timing Window REQTW entriesOIARA = 279.16629167 / RA of OIWFS guide star OIARV = 0. / OIWFS Heliocentric Radial Velocity OIAWAVEL= 6500. / OIWFS Effective Target Wavelength OIADEC = -44.3175 / Declination of OIWFS guide star OIAEPOCH= 2000. / Epoch for OIWFS guide star coordinates OIAEQUIN= 2000. / Equinox for OIWFS guide star coordinates OIAFRAME= 'FK5 ' / OIWFS Target co-ordinate system OIAOBJEC= 'GSC0791402580' / Object Name for OIWFS, Chop A OIAPMDEC= 0. / OIWFS Proper Motion in Declination OIAPMRA = 0. / OIWFS Proper Motion in RA OIAPARAL= 0. / OIWFS Parallax of Target OIFREQ = 200. / OIWFS sampling frequency (Hz) HUMIDITY= 23. / The Relative Humidity (fraction, 0..101). TAMBIENT= 4.3 / The ambient temp (C). TAMBIEN2= 39.74 / The ambient temp (F). PRESSURE= 544.70328 / The atmospheric pressure (mm Hg). PRESSUR2= 72600. / The atmospheric pressure (Pa). DEWPOINT= -15.3 / The dew point (C). DEWPOIN2= 4.46 / The dew point (F). WINDSPEE= 14.1 / The wind speed (m/s). WINDSPE2= 31.5417 / The wind speed (mph). WINDDIRE= 301. / The wind direction (degrees). INPORT = 3 / Number of ISS port where GMOS was located GMOSCC = 'GMOS-CP (V6-9)' / GMOS components controller s/w TIME-OBS= '00:42:27.4' / Time of observation PREIMAGE= F / MOS pre-imaging CONID = 'ARC-III ' / Detector controller ID DETECTOR= 'GMOS + Hamamatsu_new' / Detector name DEWAR = 'Lab Cryostat' / Dewar name ARRYTMPD= -100.998 / Array temperature D (Celsius) ARRYTMPA= -94.113 / Array temperature A (Celsius) ARRYTMPB= -94.379 / Array temperature B (Celsius) ARRYTMPC= -94.095 / Array temperature C (Celsius) ARRYTSET= -101. / Array temperature Setpoint (Celsius) DETSIZE = '[1:6144,1:4224]' / Detector size NCCDS = 3 / Number of CCD chips NAMPS = 4 / Number of amplifiers SHUTTER = 'OPEN ' / Shutter state during observation AMPINTEG= 11880 / Amplifier integration time OBSEPOCH= 2019.59898560676 / Epoch at start of exposure TIMESYS = 'UTC ' / Time system used DATE-OBS= '2019-08-08' / UT Date of observation (YYYY-MM-DD) GMOSTHT = 'WARNING ' / Shutter health NSUBEXP = 1 / Number of sub exposures UTSTART = '00:42:29.7167' / UT at observation start UTEND = '00:43:59.7167' / UT at observation end EXPTIME = 90. / Exposure time in seconds ELAPSED = 90. / Elapsed observation time in seconds DARKTIME= 98.5500249862671 / Dark current integration in seconds MASKID = 10005374 / Mask/IFU barcode MASKNAME= '1.0arcsec' / Mask name MASKTYP = 1 / Mask/IFU type (0=none/-1=IFU/1=mask) MASKLOC = 0 / Mask/IFU location (-1=unknown/0=FP/1=cassette) FILTER1 = 'GG455_G0329' / Filter 1 name FILTID1 = 20000044 / Filter 1 barcode FILTER2 = 'open2-8 ' / Filter 2 name FILTID2 = 20000041 / Filter 2 barcode GRATING = 'R400+_G5325' / Grating name GRATID = 30000019 / Grating barcode GRWLEN = 740. / Grating wavelength at slit (nm) CENTWAVE= 740. / Central wavelength (nm) GRORDER = 1 / Grating order GRTILT = 55.6015 / Grating tilt angle (degrees) GRSTEP = 5891.3684 / Requested grating motor step position DTAX = 42. / Detector translation X position (microns) DTAY = 127.68 / Detector translation Y position (microns) DTAZ = 1068. / Detector translation Z position (microns) DTAZST = 1068. / Focus at observation start (microns) DTAZEN = 1068. / Focus at observation end (microns) DTAZME = 1650. / Mean focus during observation (microns) DTMODE = 'FOLLOW ' / Detector translation stage mode ADCMODE = ' ' / ADC mode GMOSDC = 'gmosdc-6.4AT1.6' / GMOS detector controller s/w DETTYPE = 'S10892 ' / Detector array type DETID = 'BI5-36-4k-2,BI11-33-4k-1,BI12-34-4k-1' / Chip IDs EXPOSURE= 90. / Requested exposure time in seconds ADCUSED = 1 / ADC used? (0=yes/1=no) DETNROI = 1 / No. regions of interest ADCENPST= 0. / Start entrance prism angle of ADC ADCENPEN= 0. / End entrance prism angle of ADC ADCENPME= 0. / Mean entrance prism angle of ADC ADCEXPST= 0. / Start exit prism angle of ADC ADCEXPEN= 0. / End exit prism angle of ADC ADCEXPME= 0. / Mean exit prism angle of ADC ADCWLEN1= 0. / Lower wavelength for ADC calculation ADCWLEN2= 0. / Upper wavelength for ADC calculation DETRO1X = 1 / ROI 1 X start DETRO1XS= 3072 / ROI 1 X size DETRO1Y = 1625 / ROI 1 Y start DETRO1YS= 512 / ROI 1 Y size AIRMASS = 1.086 / Mean airmass for the observation AMSTART = 1.087 / Airmass at start of exposure AMEND = 1.085 / Airmass at end of exposure PROP_MD = F / Proprietary Metadata RELEASE = '2019-08-08' / End of proprietary period YYY-MM-DD ORIGNAME= 'S20190808S0048.fits' / Original filename prior to processing GEM-TLM = '2020-10-28T11:30:19' / UT last modification with GEMINI VALDATA = '2020-10-28T11:30:18' / UT time stamp for validateData ADDMDF = '2020-10-28T11:30:18' / UT time stamp for addMDF SDZSTRUC= '2020-10-28T11:30:18' / UT time stamp for standardizeStructure NSCIEXT = 12 / Number of science extensions SDZHDRSG= '2020-10-28T11:30:18' / UT time stamp for standardizeObservatoryHeaderSDZHDRSI= '2020-10-28T11:30:18' / UT time stamp for standardizeInstrumentHeadersSDZWCS = '2020-10-28T11:30:18' / UT time stamp for standardizeWCS PREPARE = '2020-10-28T11:30:18' / UT time stamp for PREPARE ADDDQ = '2020-10-28T11:30:18' / UT time stamp for addDQ ADDVAR = '2020-10-28T11:30:19' / UT time stamp for addVAR SUBOVER = '2020-10-28T11:30:19' / UT time stamp for subtractOverscan TRIMMED = 'yes ' / Overscan section trimmed TRIMOVER= '2020-10-28T11:30:19' / UT time stamp for trimOverscan ADUTOELE= '2020-10-28T11:30:19' / UT time stamp for ADUToElectrons MOSAIC = '2020-10-28T11:30:19' / UT time stamp for mosaicDetectors END XTENSION= 'IMAGE ' / Image extension BITPIX = -32 / array data type NAXIS = 2 / number of array dimensions NAXIS1 = 200 NAXIS2 = 150 PCOUNT = 0 / number of parameters GCOUNT = 1 / number of groups EXTNAME = 'SCI ' / extension name END Bà“B¯!&B£—^BTí´BPq2BcŠB‚Ó BzB4B}÷#B†w«BQß¹BN¿‚B<–ÊBQ8ÅBg;ØB…M¿BF2êBZŽÚB4ÏÙB;ÎBTfjB9r½BCÍÍBJ@Bd‘¥B>#BHˆ­BX:Bd?!B“B²Q2BÉ¡áBÀW»BÈlyB® BSttBr:QBn]ÜBOZBaBx¼©B˜ÊÁBŸþ€BŽâ9BP¶‰B]VBBhSBPF BYÓ9BDœwB0ž6Bv) BPÃÿB>dB2âúBeSqB_ÎòB°ÕCåiC ËÙCñ«CöBûJB…gÉBaaÔB@ÒFBmÝúB†3'B§‰¿B–}ÐB P¶B²n®B˜¨Bu*B=^ B,œ@B@¸PBB?©B>ÐÐBbOUB=äGBT,B¨.¦CH÷CÂkC(9C.NuCeRB¡~¢BŠSáBj‰BF¿”BZe_BzUPB³ÞxBµMÆB«ø[B¬L~B–BBk¹çBo¤ÉB%ñ†B5Ú—B| B†ñCô'C#œ?C/<ëCèBüùÎBª=’BAR)B;}ÛBL»B^LBDçwBiÆÝB–‡éBÛ¾Bß’B˜®ßB™½BŒõêBU´jBJ¦žBQSCBa8|BL‹:B†·ØB„Ç6B}×cBlB…ïØBˆ€“Bh6ÞBBBtãB“%BÕwhBÝbSB´-ËB¿*IB½ÎBÿ†°CMzB\܉B~®5B›TxC 3‚C&3C"-ÿC¥SBÿdÀB‹ëÅB^̰B[.ºB4KBNmZB8Ý-B7‚Bœº)B¨žbB¡ýÁB££ÞB¥j2BŽ ˜BdxœBU"¨BUšÙBNâ©BWiYB`,œBŒ–ìB‚ÕUB¨5Bƒ™B‡STB…’JBGBT ÷B…âB»Æ8BêEBÓ[B¿Ô­BÂ…Böœ3CA&ÓCEþCOçBC7¬&C BÈõBóNB-lVB@ñB)(þB+PêB/X¥BeþBL{GB5óBbVuBP¹ÐBÅ”B[bBJ¢4B(ÝþBD•+BkìLB…ÀíBu+™BrðrB„ºmB‚-BeBV EBAÉBŽCÄBÍÔSBùO‹C n4B÷¨óBÁ”FBǺB¶˜BBÚ4•Bï4ˆBÐI¥CÒ$CƒBã¸'B½sB¾ÐB£ÙBo{ÕBYl»BNÚB>WBn¸BAÏŽBN[BM5ÑBžzMBŒ\#BœúüBY=lBX§¾BqKjBŒ4ÌBŠœˆBŒ™ŠB_Ø BhûEBj±ÂBSظB>r BkfBÜAB@U B*Ê|BCÞlB2€'BYn[B€í³BJ5àBV5B@˜ÊBFšÙBF±àBN²aBS8|B¤UB¹dbB®É¤Bá´ B¾â›B›†µB‚U¯Bm¶vBvéCBŒêTB•ÌØB¶)qBŸ BˆÅBf‡ Bc!ÐBn9;B_ÚBRžæBFð†BFßBDðB*¶”BbÊPBkú;BDZüB`3BR*ŽB™RC ašC5ŒCãQCö=Bö¡>B‚#4Bnø“BSö+B]@ BŸ¥B£GQB¥•³B©v|BÃeäB=áBJüB^.‚BF²BBî‘BDuéBw[¯BfHŠBoJNB940B»wœC iyC.ðtC–C@KC´æB{}B\RB@‡.B†¼B_1)B’•ÅBµÛŽB¾}¥B·ÆkB­­Bœ~ÈBZTïBr?ÿBEwšBmÏuBSé¬B¨P½C-âCƒCž´C ?ôC kpB–Ã{BJ‰­BC B5ëB1äB2¢vBMã]B¡-ÑB­-rB±ŽBÅ(ÚB¬ñYBƒ{oBZŸïB$˜=BUa¡BKÊB)¢ŸBN)B:hB‰šBxÅ9B‡ÒB]ƪBg·ÙBQ¬˜B\t3B’äžBÈBÑ ¢BÖ¼\Bàö$BÄiüC/~CEIC<àCbfvCQó,C‚BÖHB8ºB@B3bÄBFÏÕB7«áBOG"BjØBiíB%ØnBFÂ_BWÂHB!ŒoB=¥¯BV\B ÈÔB39kBBwUBm{ÏBÀKB‚5yBŽ#BZË4BcÏÙB\¨ BO^6BÈBψ"BìÏOBýCýˆB¸,ÓB€‚aBÊaÞBÛŽBêôOBÖøtBÿ!3C̼BîrBãBrþjBuÔ`BXƒ–B‹OKB¯¶B³bâB»B¶">Bw™BBs‰×BQ÷¡BxV¯BN×¢Bc;B„ÌxB?öýBOT¡BScB²{Cá]C#ÖgC ÝåC aC!9B¢^)BQŠBNÔ¿Bm+Bcº»B¡eB²e„B¸hïB·°RB¿³ÂB£½šB>º¤BjQDB>$BTùÒB31ÃB™ÖƒCÄÓC1gCitC±¯C7ÛB¡RÛB5ÔÃB [¶B0öB@›hB>éBzTKB¥ BŸËþB´?B·mBž-BcžB>B)ãBEÚ­B.áëB,-BVlBŒ¹ËB‰†B”ÏB‡¬ BYûŒBK„¬B,'B3©ôB¸–œBÖ•oBʲ-BÙöVBËo™BÁKîC:”C@œC:0ûCE•SC9}æCº©BŒ¨÷B0šNBQn!BP²¡BOæB6ì‘BU«´B|J7B€yBB@\èBL\B?¬óBGQ­B< LB`ÐBIdqB/¦BBTÁBtKB‹tËB—öµBŽi B|¦†BF*{B˜ÓBS¼ƒB ìîBÇ“žB÷Ý BÿÀZBý šB×.ÍB™¸µBÍZvBÔKÜBùÕBØsÍC›íBðì°BÕ:B¿I‚BÅÅ™B¬#BƒøB‚¨àBPU\BJªgB,# BIQ6BcPB'jcB‘h?B™%–B€å9Bnª-BL8{B@6HBHâB‚>)B™ãBwÑ?B_©XB`;BH$Bf}ˆBj[¹BB;ÿÈBLÆB(dBDþ©BKHFBOlBe<|BHa÷BC¾xB=ÁÈB¡¹ÔCgÚC…ÖC®FC }OBß1]B‰5âB8Ô?BX)aBXÇBˆyçB°ýB|B¡›ŠB›û£B’/Bs™*BQÚBŠÞáBŒ£ÄB‰ºB޳+Bƒ¾ÙBd@BKjãBarLB’FŒBÎ<BþfÅBüÊÀBÝžBÂÆbB¡@¬B´]sBÀ‡ÞBáBÐ&jC Bð¥BÜEJBæb9BÓ¶nBµbBƒ6ÊB”³B2HJB3¦IB6zBO—'BcÙ®B8¡B“x[B—’„B—×B~¡kBHNšB‚ kBsÍvBŠî¥Bˆ9jB‹²aBg9kBLÙ€BI´~BBèñBC]ÿBIrIB8Û˜BFB[ŽBO|B<àBSn\BBˆþB80ÎBm¿äB:÷ÉBXÖçBD ´Bp%õB–69B±üýB¶DîBºUBÕæ­B¢K,BarBHá1BPu’B’G.B”y®B–?†BwB=B¡ÇB`ëûB^ßòBnдBq^ŒB@eBHK1BWn.BÅB`dhBt0ªB€´'BZjšB?XÐB4Û>BŠoCp™C„CøCèBáuRB‡jkB\SB\7BSîýBl.«B¢QlBª”ÍB°$[B›ìãB’B_BW‡BW .B?ÉPB/s˜BBÆBJ!bBV ‡BVcÖBC°YB³\dC*)C5î{C›“C'ŒÂCiBqÏ BX^B]BM>BT¯LB…NB¬~BÈþBËkB¨#RB® }B<QBg1¿BV^B!)éBO,ºB¤“ÉC ÉCkyCþCù’CMœB™~KBGsÏB?íÚB4¤oBAHBGÌDBia]B¢“ÄB )€B•e½B¡ãSB§›CBV£LBG'ØBGÏ'BLלBDÖ”BG‹ØB~ržBƒ?B;B‹ˆ¾B‹”ÃBqLGBQî~BMØWBc5BŸ¬€BÉ™*B½16BÖjhBÙÏ'BÏ}UCyùC61ÊC4m%C,´:C:%‘CX+B„ÈÝBA¿¤ B-ì?BH…ØB=›ŸBS¥B25BD"ÅBT"êBeRçB€6B†+0Br¦nB‰·×B‚̱BWEÌB6ƒBg SB&xBÌEÇB÷»;CG5BìÑBÁQuBŽx/B³P_BÂäÒC©BÑUíBü–úBå~ùBÞÀ‰BõäBä³!B¼É^Bx}ŸBHƒìBL¦“B*ˆñB&ÇhBA§2B<ÜGB$²·Bžÿ%B‚iB‡iB†0JBz£TB}ôBylBƒŽ»BàfBʯBоB[BTBEaöB‰ÑŽBR”RB4™`BMŒB$8iB`”÷BL®BbE²BGhBJ—¦B^¿B`>BF¾ABJÓ#BlyB¤XÐB­~ìBÜ¢jB¾àBØ2RB¥ŒB`³ŒBs/DBc •B«r•B‰k‹B’*BŠ^UB޼BfÑãBdémB>~ÖB`‡PB:¬ôBfרBZ!ÑBz>ôBbôwBcíBoØuBWæªB<…BT¾B£‹CvÁCzcC C Ü!Bç8wB!oB_ìBYÊQBTðBk”B¨B´z˜B£}B›4kB™!+BZ Bf¡ÏB76kBW4B@úiBIñ™B9ûBX +BZ¡´B® {C$' C2¥6C&³ÄC6ųC"3^B;àBC‹$BB|óBeˆBbIPBtkœB¡kÂB¸ÛCBªÛ#B²ÄB®µ­BB<‡BI@Be?÷B'êBG¤-B¢C&ûCšmC CÝuCÑB–ÄØB&!ZB4&B*ǼBx=}BRMúB^ÿB‡éB¡,LB±6B¤Ü B¡OàBT¿ðB`r)Bjs±BNgBH¶BW BƒŸåBŠÅ²B† ‘BŒhB£B`nPBK…qBD9.B`¬ÑB—|B¾µÑBÁ"}BÚ:‚BÙo BÆ’PCþúCAÐ"C@æ{C4º$C9;C-/BtÊÍBE¹ËBP¥ðBU{oBIVÊBC¼.BA‡BIY­B`aÐBJ^B8£ÍB>Ú.B3B`\ B^nBN†¬B2èB,ìÅBq}œBŒ‡7B^~B…=B“C@BXBF@hBU{pB¡;¯BϱBù —C#;BñC"BÍÈñBšf+B¶KBÈÔ­Bë ñBÛÿeBùÃ’CëíBÁ$åBÏLqBÐuBÆ÷B’¤™BU£ÒBl- BAhB0‘vBH§ËB/hXBB¯éB‹™`BŠ5ãBX‘BlÈ:BsŽBnqHBgØ•BŽ¢BŠyB{D¦BaÖ†B; B1CBe,wB|ؘBSitBHBBaÊ BH ?BuTÒB|CßB€tÑBSb½BJ@wBSn@BNõBQ-™B=×™B\BÎB§BfB¯¥@BÎSBȸ"B¿ÞB­¿ÒBMa BaÉB„©BûkB‚P#BJµB“r/B—›B„ŠTBVkuB2˜TBh}hBfrUB€Ø¨BP<ÅBPöB]¯Ba³éB?)¡B\âCB5%6B[7WB±äàCH-CCñC†PC CåBê5/Brt]BdBSŽÅB„ÑB¢OvB³“¤BªÚõBŸò-BéBNBAì[B;šB*VßBQtNBSNBYùBEáÑBJ¤BOw§B±U›CµEC/yXC!xBC1ñPCÉ(B”ˆŒBF—ŒB7ú5Bl¼èBYáBbͤB–p‡Bª}°BªôëBÁûB¶­dB^«ôB5ì?B9î5BòBC&ÇB™k‚C ¢CHCm‚C4˜C hB–ZjB5BöŠB;µBx'B.ÓèBSKvB–)ÛB«.!B¼omB°…oB–ŒiBQõ'B^ÇÖBTÓÄBSDB-ŠBCLGBX>ÄBvß!B`³/By¡ÜB‡ÝBe¡­BóCBS[ÏBz–B¤aEB·¥wBÌÃBØZ BßS"B£ÒC áÑCF®oC:•CH:–C2©C4¹BfóB0…B´CB3ËBO³EBJážB0¾JB1¬BVdºBXY°B2¶BË’BKðÆBEŽ)BJ¾ B,)7BX‰BBi[B`ÖÂB‚WYB‘ êB†¸ûB‰}¢BI\2B 4—yBDù B}[×BôÃB‹µ”BbXÏBT(0Bn•‰B^OpBŠ­>B}µBW‘RB4ÄBb¯B1Ö(B[ø¸B3fCB1‚®BI­B8C­BEcÎB\Þ BeìBFÙ BM77Bk)†BH$BIðBÌÜB2‹BR‚ùBŸ©jB­o B§·þB¿.±BÀ]B›ŠBM+ôBU%KB„ÑaB‘ZB£ ÉB<ÎB²5B”‘•BµVBsnBWùUBjÂïB}©bB"BWF|BI]êBj*BNWôBN‘¥BT¼|Bd¶ÜB_Á¢B·MbC÷C 1CìCô’Bé»sBz³²BA)ìB;} BW}KBGÝB·WB§'CB¡r°B”MËB‡\WBK'œB/”ùBM¸VBLF%B]ä¶BVßBOHVBY«òB1ËQBÁŸ°C(˜öC‰¸C6`˜C.¹µC‘ÖB•ÿrBLÛ/BOxjBfú«BG׉B~ÄB´É£B›’ØB²=·B¸ñ”BÉBB^Ý¿BDÛBCY‰B:¥¨BEí&B€î¬CWÂCLC¤ÏCÄœCª„BœÏB,væBF’B$_¿B1}nB]ó"BaAIB¢í B£°ºB¡8ÿB«*ªBŒv–BhB>ŠB>ºÙBAT;BØUBT%†B2f Bv{ãB^îB …B‘ŒB‡–B#ÊB[—JBd°!B­Ý‡BÖ³ÔB¹óEBÀô Bë¡üB «,CÞÞCH…‰C?;-CAMòC5zÊBýº0B‹+ÑBKáBéßB7CQBm–øBXÙ^B-; BJÑB-øyB[…BN·%B&'„B9hZBBþ1B³†B BCÛXBQ»BBg߃B¸}BmKøB‹€êB†CBp&½B}BW·òB¦KBÀ6¡BùL Bô/gBéÜŸBÇ>%B²3ŸBÅæeBØm§BÜ'BíPFBï‚ÆBáÆêBÊ[BáfÃBÛ'B¯¹B\QÔBk3oB&›ÝBUt$B8÷BC%BNËVB7%B‰ZeB‹²BŒÍšBJæêBG BWû‡B€gžB^?ËB|5B{üB]ð'B'^BI^|BgÕ4B(§B4ââB/üÕBDHvB1ðºB8fâBA£B.ÑyB íœBIJVBDÌßBgÕ4B:Ë B=ÂóB]Bü5B­\2B¢Ç0BÁ¯¯BÒƒØB‡o´B8åØB9‡bBm¦žB• €B„݈B›TõBœ SB–÷,B})ÃBOÎABX'ÀBG$B'?–BOÁBBFÍB<1Bhì BAˆBI B9ÑkBTŸçBZ˵BÀŒVC7pC%iC f‡CïBî6±Bk¶wBk6BHX¤B1’ÙBƒÔ&B»AB¶®ÝBœ×úBŸnyB‰nÂBuRB1 Bm(¨BELB[AB|vêBIùóBG¡ôBJÊšB¶Ð C",C÷VC3û®C%úCXoB–î BRØ#B^HB]•+BDüB‰e BÁªeB»¥Bª´‡B»xXB·ÉBHaLB82 BWª¿BG$óB0æ¼B‹ÀüBü¬›C^hC ‘C%´CÀB–‘»BAB<ÂNB?žB5,öBQH#B[ZúB‹ÓBB+B‹å B¾\¹B¤eB„ÊLB=ÈÎBEµ¥B[c¢B)éQBtÃÄBhqîB†®nBMÜ-Bk.äBŠÚ³B—;qB/^mBM'iBU7ÔB–8ÊB¶ gBÂV‚B»è\BàwyBĵ¸Cm(C5CC>;B0ñPB7¨ŠBjäB8?B?ÑõBSNhB8Ü;BmíBEБB=3ÄB=|B"Ù¡B B&–[B/wBBí%B‚g>B}JtBbÛ*B•½¶B’~wBPëÔB íßBF&%B w`Bµ 1BåvPCÞlBëÑ;B¸æ+B°û@BÄ“BÙ4ÓB̧ÙBá>‚B÷ã!BÍùÔBËwBÙ}kBâ^B¡i¯B; B7‹±B6Û»B=¬ëBFÙôB@…ÃBXEŽB(KÛB—2B8ÈB‰¾BëDB0ÏB<€Bƒ2¢B‰]xB{Ú9BrÊ.Bg~IBCÅgBQ§YB`uSB'÷ìB*p:B+BNì×BV ÞB0g»BQ<ØB:•³B2žÉB4ÍB>ÌBCîªBSGÄBVå¬Bd9œBšÐØB½“žBŸ,‰B­¿ëB¶TŒB”gyBJÖFB>0ÉBZ)XBq|B~‹¿B“‰\BiiB ìFBYëÎB+BBX;BDyBñ‰B'úCB'µþBM¸¼BVÞBMîBaÔÍBBn\B@:æB]B³ójC€CyCaÇC +¯BÛ›ËBrJ@B2¦òBiú_BAÓB OB¶áiBª»SB±+B®bkB–œ`B\ôºB;ݘB@D„B=Û5B; ,BRžB'èôB3´-BK²xB¢€™CŠõCš’C2ÕC™×C ýJB—mBLÛ–B3YËBX•B:à¶Bz?¿B©ñBÉ[°B¢B¤ýžB(ÐBHÔÑB8`TBEôHB&aœBk”B†Ñ™C†ÑCRSCÝCœ6C ð B…ÃhBMÇ)B;%ñBRUB (XBñnBG)åB± B–ZþB’£B¬ùØB ‡BH,ŒBj\sBQ2B12ÕB.‹BRj¨B_N¦B†ÖãBA»„B_^ BjZ†BŠ&{B^PÍBOÂÚB[1B š‹B¶è BȺ&B¸*BBÝ×èB»÷CÏC1°C=!‰C=SC2¢C!¿Bsj¶BQãB&½ëBÀöBS˜”B,tiB?IŽB0¨_BF7–BEÊïB0‡®B!võB { B;S"B+ÅjB)ä¥B& Bg†}BjmÂB{¿BigAB”ñtB‚ÈèB9Â,B&¨ÃB3¤B£hTB¹~¤BêÓïBüFEBÂ%BŤ@B¡üB±Ÿ¾BÏ&`Bà¬lB¾ôMŸBA6/B1bDBfr²B—Ó:B«øzBžâèB²ñÔB!:BðLBMbjBAcDB@—lBbBˆujB‚«°BjB³BŠ`BBbBE¤°B\/ÓBT¦B\£6B#¿ÊB;}¨B<5OBEu’BOKÖBVÄUB?˜BAåBcÞ+B¥üˆC½ÆCI9CkBüŸRBý)MB[gBQG‡BD B=lB‘Þ‹B¾¹5B´Û¼B¦NCB–‹-Bk˜ BI“jB3äxB›ÖBNÔ›B.³ B5ÙnBBDCÎBUFšB¦[¹CáúCM@C-G0CæËC"¡B„ BcMðBJ ’BZ&­B:Bo"ÇB§ñùB¶R@BºãõB—ÒB›BÝB-/*B6ëwBC'1B:úãBC CŸQC-ùC:CèBƒ™0B.ÎŒBEÖ°BEu’B1I)B ;BGµˆB®ÕB«FÚB§ŽtB›vBƒéBIíÍB]“˜B9ÎãBOEB8¨¨BHÞ¥BeñæB†7aBZ+{BE,B4äBf^äB4»nBj/¦BmŸ€BJ9#B;ï‘BEx‚B\åNB9ÔVB2RB:ãßB?ðMB94BA,îBU)áB[“‘B>-WB7—…BJeEB„Bºr«B¶e›B¸~pB°êB–3"B(‘PBYzoBU“fB‚ B€:%B ÙBy—‘B†ì‘Bd†PBRJBBÂB8µBIB…BKhBOõçB@fBB$G=BFÚ-B?ÖB5±âB9)`Bu©ÍB¹“×C cuC ÀCC y—CÙoC BƒTÛBDÅ|B-tEBeXãBUî¿B¨ý²B·ÁB ÛBžˆÈBU7B( B>º`B)ÖPB_3ÑB,þöBId-B6WDBWÜBH0|B©CiC#VC'ÙC$×NC+xæCM|BgÕmB=¡›Bl¬ÙB=àB"YøB~‚8B¸™\B¯HÀB²BIBœnRB››¿BK#B8ÞB*íB>áÌBP "BštCÑC­C0£C `ÒC B‡VVB{ŽBZm´B=õBB;CAë¾ìB ð·B“_B”ƒâB«tòB ×*B‘œžBW fB@¸óB-€ÅB(ËBCŸB,Y”BibŠBu %Bƒ“ÖBvrB`…PB„åBayŒB0ˆ»B9AjB›º„B±ù6BÄ+_BÊ‘ÔBÔGáB¯zÀBï C;TC=î CC´ºC6ŒòC »®B|¸‡B:4¯B‡ÒB5¬BH.BM_gB'ýBáÚBàaxC»dBå6|BÍŸBÀp‘BÕ‹pB¯+èBh¨÷Bbr•B56ÎB0»±Bc‡B7ÎCBAB!þ B†®eB…#BRBƒBA œBh×BWg B„—BN.²Be«ÏBSgCB‘ÆB7ÙBHh B?B‘É—BŒu¦Bt¥¿BÎB]\:B8 TBCêC%üòCÇôC2W2C ZB`jBK‘nB+‰sB‰‰B9qB€†B©ìlBtšB¨›âBµ:¥B™?3B>†úBÔ÷B!ëëB?o«B= +B­WæCT€CGCЉC2ŸC?¡B†[¢B-¸B!ö~B(ÛßB ³BU4B)?àB…5hB§5BªQbB“ïBœ^·B0$B<¬ðBLÂâBÓ¨‡BêoCËBÚìžBÄUvBÅ4BÀižBÐóBB`æôBv-BHPBVÂÎBF  BEŠ)B*§}B}NB…ØËBqðñB†R¦BWMÜBU"QB4ÓˆBO[¿B^$íB7¥BbS·BW%B'ñÅB=PÅB;ÿBG×BVvðBO”[B2²ŠBCV«BBï B%fB"‚„B@[àB2f¾B<àB5?ôBKM•B)ÝBO"-BŒROBº9£B´/ªBÅQ¼B¾¯ªB‚åB_ð‹BJíµBMQ?B~{ÁBô{B‡ÚBšÞuBŠ,mBZÔÚBT?HB:BMðÝBkÊ0B=‚%BYlGB_lÐBM=BB#B`XcBUÛÈBFABq÷êBœœ›Bý#šCƒªCÇÝBüÜsBçXÅBp»‘BBb7BRÍBK£qBœ5ºB¥÷PB—EÈB¥iB¥ÚóB“tÝB0_¦BKNÓBZ§ªBɽB?ðAB,ZÎBlXB-5BBhB±&IC$MdC*VCW4C%á¸C íCB~(B,^§B.ãØBefB ‰ÑBnœMB§˜ŸB¤R¤BÀ²B•šÝB `BY» B?–ÕB-B&Ä BLŽBfhCèåCáØC§{C­CÁ­BNTB5íÃAè;uB2>B,ÇvB0úuBWÑBšÏBŒÖ(B¨\ÆB¥7|B©ÃèBL†]BBgüB,,§BŽÛB9XÃB)YBCzüBH4™ByX_B–g0BbÜžBSÎÈB5»ÃB"ã¼BTŸoB™kMBÁýUB±2NBâö¨BÔ³µBÂEsC µCO”sCJ C? 4C.‰”C ‹æBƒìéBCúÞBú¤BLº B ŒêB¬­B4¦KB‹jB§ÐB±N[B¹µ¡B¯“âB‡ÉÚB[ËøB1RëBD¿Bx/BŽ•ÀB”—?B¥Ù‚B“VBNqµBY[B4dB2Ò“B‡½BI…"B;yóBxÆ8BoÒáBQìBLÿ…BF«TBP¡Bió B°´XBý\ÐC¬ÐC¬C­}Bü4.B….ŒB2U’BA ßBcµíB°tâB£B‘t]B§‚üB£á.B‡€ÇBZZ½B#dBf0ŠB+¼(BFì¶B4+ÄB>òiB(»ãBXÚ B™kÉCÛÏC$ðÚC NC±DC ¼yBŽcÀB$•BSé´B(æ2B b6BD%BËÌÝB¢‡ýB¬% B”öìB“7ÎBWÙeBGßûBE©£Bý\BOBˆ‚óBò¡:C9C¯ÜC sÜCB„óiB@êAB ”dBµB3ÐkB"»ZB_ÊB­±¬BŒQwB _–B¤r_B˜ù\BYÑBX}ÑB.ÕkB&“÷B‹+BFèBC­BT}ÈB€[ïB”ÿBZÞxB~h†B1þBÓHB_ÐÐBœHyB²æ]BµÁ!BÍÎBзÿBÈàÊCîéCYãC[Ñ#CA?CHl÷C2ÊBXp[BU»B=€8B+ïB-p±B(íãBgàEB>_B8tBa1²BSÜB8jMB4ÙÍBÂùB*?cB˜B#CäB_ ¼B“‘;B|È.B|ì¸B‰ô.B†–¤BGn…B;ûÂBEþ@Bž ƒBñýÄC•óBð·SCBþB¸ &B‘:1B¦2BÙ2/BÛ{GB÷VBÿ:²Bé…ûBÊåžBÒ®gBË'BšsºBt œBY¤ B?ÂB=ÞB0±B>$B-UÅB>ÍßBä™B‹ž™B‚Î]B6OáBBûéBcþBj4óBD£ B~'YByÊ€BM ÛBR$B3}B*È~BJîBQ\BYˆ0BQTÔB4AB?q1B$?&B@B3^®BF-eBOÒ(B8)ÞBNtæBóB+ÆÂBŽSZB¥éhB°0òBžA]B¯qZB“ÙèB??B,³nBMí-B€CB|%×B–GŠB–sJB£¦ BV™]B+odB8“ÎB8g”BcŽªBLžBBå%B7 €BTuJBkàwB[„BZ°zBUÁBYÍŽBÂ/C­MCsÒCç}CùIBù&ˆBgxB5AÏBR‹ÞBCÃB ºˆB¤»ˆB”·B™€‰B|MB„ìÃBKù.B#e´BX~ñBI?BRˆB'`ïB]BO7B[éðB™ŠC+!C7ØC'Cí C r8B‡" Ba…B?–þBg<øB<óÿBj 3B¿9¹BŸSáB¿·¯B ™×Bœ kBE½B€B)íÑB-/wB*ß)BŒHiBþ̯C/íC³¯C ÿÐC‘BgRB@hœB6˜BM¢BAŠB'qHBc£ÑB©>UB£ÝåBžæB ÿÃB¢y+BU¶BqB1”wB9@âB±ØB>:ëB;©;B`L B_\BéBCÔ’BWX¶BQIÁB)×´Bb 4B¤ÎGB¾…êB²ÙvBÎBÂ3BB¼=MCòECL<>CFGøC=A(C@+CLuB])+BAËjB-8B=kB"bB40»B6’YB.°B5›;B_`yB2IC'#B¼&µB•´çBªÊB¿^¾BÚäàC›C!jBÜ[fBâèPB¿Â¾B½,ºB›c:BMãB2ÅFBB|WB’ÊB7cöB¬B@ aB#7ByíB^iBj^ÚBgêcB=qxBZå BjX"B1 BU¢B‚ÌÄBU"dB?t·B4½‰BTBBüBD(ßBInßBNø BW?B?[ÄB9SóBDö3Bx’BN]B&b³B nBFÛB19ŠB1£B€ŸÉBÃ+ùB´$`B¹Û}BŸLóB”ÑMB}OB=ØqBBÑ„B~ZÓB…ÃwB•$zB˜‘àBž¨‡B:Í™B$@‰B'À°BM ÛBLV BE5B>¬BL-ªB?©ÓBRÝ3Bv¸BVl¼BF¬BPŒB—_ C[3C¨kC{®BýLYBáà¨BMmÛBO+ BcËÍBT:=B˜‚~B„düBŽhqB”ǯB‘BˆäèB+‡þBHÑBW³¨BZdBJ« BA(„B$yDB7´UBVÿÙB›ªCòÉC$,)C%~$CƬC] B"B‰B*8kBWSBX™wB6 AB¶ ~B©šìBÄÖBŸƒÁB•«B`kbBp B Œ¿B<,BDãRB‰>ÏCôCàECªqC¥.Býÿ1Bs BBZIB$üÿB"ÙBKµyB?^ÔBh~¯BŒD]Bô¸B¢ý¨B’°B¡¬¤Bqö¸B-;’B/ZÖB3B3‰BxnBKDB;_Byú¢Bn—BBKPƒBBϘBUTíB+CBU(Bš QB¹§Bº„¸BÕÈ‚B×À[B±½!BöÍ_C<$®C.2ûC7¬7C4Ÿ°C A”BWùÚB9Ò£B’äBIBB9ßB(gÿB(üB18B1%}BW”B#C§B˜ŸBAù,BTÛÆB3“›B)°×B:¬èBr˜BB‰ÄwBœ—3B|ÝB’>¦Bc°BQªxBPÞŸBj ôB¹ýBÉtDBçõBå¦ÿBþ=6BÁÐB™÷B½DBÐ'+BÞh2Bëü¡BúŸABÒþBÏUBµ B´cùB²{þB–PôB^¤”BA³ñB-1ôB&óáBT[äB-—àB-­B† ‘BŠ˜GB]·,BePB?ñöBQׄBNcÓBQÂhBmŠ"Bdƒ¯BL€?B<´B-ÀBB,ØiB+NB2ÆB>™B@ÀuB$sHB>o0B.áxB?‰B7`vB2ª²B3ý(BM/$BX®gBIIB/³BB~B˜çC÷ìBøý\Cƒ4CmyBÒ¾…Be|GBlù•B[gBH°.BŠìB¦*ˆBŒ0ŒB“_öBª•B›ò«B:€B-¸ZBIÂBOL|B$æB-N•B¯BAWkB{v:B¨ÿ‡C ÔC@çC1Cù C!™tB•-ûB0ÐB@­:BRjBd4eB€ ÝBÀÒB§ 3B¯±wB°S÷B“!wBd<BL’iB¥B;ÜŠB\ÑBƒýCŽÞCQöC C0Co)B™ÄB6ÆžB!„B[‡BLñšB*qåBLsB‹û.Bˆ›>B•¡ÙB<B–hBfúB?NDB7˜;BEž›B'œåB#BNâ¸B|~¦B†Y×BjÊîB`ÒBXŸB~·BF7Bk‘BæB·X˜BÖ@BÿBÍŸwB¨VLCLzC<‚ÜC3—tC+4ÒC>CôÊB^ßBçÎB‹òB>0°B8JB-|½B)ÚîB SB(üÑB3 Aÿ½ÄB*ÞŒB(×RB$LÒB'؃BBœB'o´Bl½÷Bg&=Bp£B†‹\BŒØÑBa+BS»B>b°Bc#QB¨›BÖAŽBêÊÀC»CR¾BÅB—”hB¤#ÈBàC‘BÑÍ,Bæ¾8C-ŠBó;BÄ?óBÎicB­DËB¼0B1çBaÐÜB4~÷BË#BJ>BBnÁYB4BA=uB‹úPBŠBŠççBNè5BAøB9ßBaó^B_\Boñ#B:îBLVöBC3»B-mBKiBHdŸB8šLB&EqB=»ÖBMˆBµÉB:¶}BD¬ÏB$•¬B$P—B;§RB>¡'BA]”B+ƒÄB9îêBŠá/B´^·B¹fB/v{B cdB=WB‹¸ÒC EÛCº(Cf&C€BõuüBpGµBHÎíB'È$B,`B8@yB$·†B.M^B¡ŸB¢¶bB«w>B¡R"B˜!AB`šBBHŠB9:yBL×B ‡B4µ¿BA_BŒbˆB@ B‚TBf™ÔBHW²B=ò)B1EñB1 6B™ÔÕB¶RB¡ ûBÅ—BÁ)Bµ_C qCIšJCGRàC8=C4>ƒC^ËBw§4B>ýxBL¡ÅB'šòB4óIBNï1B<èÇB7s«B13«BW1BBÊ‹B7žðB6BÜB-~£B&wšB:B;±>B=èŒBˆ1vBm6"BwïBMµ»BtÈB3êÝB5DB!ü}B¥PºBÔµÞBبBù¥Bõ‚÷BÆÏ:BžgB¬]ˆBÒaBƒÅ1B÷BB0¾BI,BS£eBh ÏBl„zBfêByQ!BU…B)`5B:&B@ÿÝBE¨B:ÙB,qBEûûB*A°BØéB4}B/QõB4eB(5ÏB¡,B‹³BD½nBkB2íòBš ýB»XõBªömBŒ9ºB¥AâB‚ÁBUêÎB>DùB:©æB…)B{дBÞBŠ ;BX©°BMFB$õB"†B/ûKB^ÖtBOèYBD¶øB1†{BKnBA4åB\¨ÃBK¾B/eJB1LÊB°RBûTqBÿŸöBþ_ICáBÛ±èBRš»BnìB!¢9BUjìB‡!âB ÓÀBµÏ_B¨£¿B“·þBXè0Ba‚B&§ÌBBƒB=àùB7áfBf‚ßB3ðÀBýÿBSÒEBŸÞC'«C 4TC*÷C 6éC äüBoÊÓB47çBKxÆBGc•B2ä{BŠ?BÑB§;,BŸéžB©<'B– BAÄ*B6e˜BGSžÖBÿ[B>ùB–æB¶X¦BºaÂBœõ‚Bõ­BOiB;.ÞB`÷ëBa·DB‹,BÜüBa—‰BˆmÀB‹(ÊB^:öB?±¬B:?rB@YñBRÁxBF!¿B7‹#B1*sBJºªB./BDñæBT—©B1ŸÂB<èBŦOC K>C ãBúüBð–BÈ÷BfèBïŒBA¢B;óûByÄñB¡´iB²¨MB¦!B¡1(B‡iB9ˆÁB) ¦BI—RBJd B=çBEˆÜB=6B;m^BPFÛBà †CE CTnC!ýNCxMCŒƒB„‘ÆB3q$B)~þBHï B7ÀBuË£B¡ ²B£ÛÙB³KÃB›_BB”læB%2ÿB?PŽB*KÍB©B3ÀóBvYñC»âCm>CèäC¸åCèŸB„ßB#ÌXBÕŸB,fCB>E@B!²ÙB! ±B{à]BŸÑ¸B› *BoŸB‹ vB^8B;BBl¶B=#B)I&B#—vBg:ÍBNŒŒBVÙ‹Bn9.B[vOBf±MB !B3_ÖBlD8B¯Z¡BºRQB®'æBÀ¦BÄEmBÀ+èB÷BFC;¥C3[rC3rICBl¦Bþ @B:ñTB½ B6KéB.^B,„B3:UB6BQã[B@ÖñB9SÞB¾YB!¼vBí¿BßnBÑPBnxB íRB6ZUBjAÌBn¼éB‚^ËB~ZúBq»ABøwB. tBH¥BKÌBÌÎÿBç âBÐ"oBà^BÃó7B üÁB¯v„B·îLBâŠìBá¾Båü,BèõBÃäOBªß BÑAïB¾‚B€Ä³B:{B.¯B,caB:è­B=Â{BJ¹´B/ÚàB‘ B…pˆB…q~B`âBVîBUÌÌB\àOB|A%BuÃOBƒ.ìB6|FBCfB'i7B‡£B>6½BBÛŒB2 ]BAüòB'׎B0øÞBOIB3¹"BEßïB>?`B7µB4ÏbB7¼¿Bt{B$gBHUB©nB¬[´B®~BÉqBªf}B;Ý'BIsBTfÞBŽÛ‹B€Ô5B”0íBb¯B‘‡2B`ÒBROKB? “BFøjB=¼õBJTýB& «B@ÿBàB0€‚BäÔBc´*B>Ž“BR¾ÔB§œC ­]C7þCáCg`BÒ`™BRD·Bð˜B(æ[B91B†f*B§ÿ–B­¸B¢Ç B¤àB‹$BQï$B4*B7ùBEŠBn\ BScABF#êB_à\B.¬=Bɲ|CÍÚC#w¼CâCÜšCª&BQaB+qQAø¸íBG¬8B™˜BxM;B¸iûB¬@‡Bª‘B˜×OB†B—B]pSBJ0sAîB2J3BnB~öþC*fC•çC ÁUC&ÈC0“BžnB áB#X?B)œB8 OB –zBS¦B†xêBˆ×*B y¡B˜ýÅB€³ BDŒ9B(óB*4ùBBBDFB.~BWGgB@LºBL@UBƒx+Bv|ÏBhCxB6ãB8â¨BF~MBˆ½¯Bª¸8B¬ÎZBÇvÛB¥étB¿+MBöfC<þÐC0ªCAd C(­ÝC€ÍBiLÛB ä¥B6žBAȉB"/"B6ÇŠBKØFB¡ùBBFgB4¬”B¸+ÝC·¹C0ÕC!©èCçCÑQB—šcB"ëfB Æ]BU B.'[Bz_ÎB¸žIB˜‰ÏB¬ßB¢àëB“ÁBn×ãB<2‰B3)BQpüBcuyB–£EC]’CžyC è®CSTC "¡B›ë0B9Î B-$³B_°B)[B.hBe2ªB{@ÎBqåžB~§ôB¬x2B”™Bjp÷BƒiB'·HAø†ŠBKøB:±BTM­B]CæBS[^B‚fBx °BrÏEBCMBH#CBJýB“áüB´BèB·2ÓB¸y¿B»RBºìBùoþC>‘hC6ËÀC<ЍC2VãBÝ-áBk:äBÚ’BuÊB&,B™gB*ooB51FB2~äB7öB8 öBD_ÍB(B!IB&»\B4ÿFBìSB8çEBS¥hB`—BxðBY°„B†ÁjB…èB ´àB>`:B*6´B)BÌBìÚÙBò.ÊBî6íBµ“qB’ƒüB°JBã{ÑBܱ×BëÇ^Bñ ˜BðhñBÝôëBÁHB¾3œB³ÔB`éB[XŽB- ©B:öB%B1jBP-èBLßBއB¤”+BkWfB£B,¾ýB.æ±BYB‚ rBi´B€µÞBA}ÁBHOBJÄ|B4WÞBm`BM2;BG¿#B;CBVBA‹0Bå¹B'¼'B+º÷B ®eB"4B'NÅB¯BO_²B')YBŒ‚B¸.B“fB¾o¯B±h˜B™l:B)hãB;÷ÖBP IB”æB’B‘ùBˆˆ­B"BxeýBZ¾©B@ZéBdYOB;RB^s³B8¯BWhÒBeä€BL¤B7šˆBIeTBB ÁBYJŒB¤RC—”C ðZCTƒCBöBÛ‚Bh#€B>»‡B =ÇBatíB’"ØBÌ„{B¨‡ B–ä¡BžKÒB€Å/B.(DBR\„B,@ÅB7vôBA—ABJ†¿B-gBR BPe¡BªíCWŸC2íC&£îC#?©BüîB²„ºB1;ÄBHÀB5¨tB)QÏBÞ|B¯ç€B¦êBœf¹B³QB‰ÿ3B9ò‡B[´ÑB>ûóBffOBE7B…#îCsC8C¾£C ¼íC){B}C-B2ýÃBW=B QB*TvB"•B|‘KB‹•íBwPBŸÜLB¸:CBŸø©BoáB=>BªB8è/BCÆßBPGBCæ™B~ÂBW˜åBv4tB†&BUG BPùµB_q‹B9ÒÍB¢6³BÀ¢©BÓaB¶úB»[´B® vBûînC:î&CK’C<(TC-dˆCW8Bsë×B(¸íB*eÅB3ØÿBy Aï•þBAqÁB7q0B*ÑvBD½B@LBTBHœ^B”B<6VBBÅŒB:gÖBhJìBi+ìB|LB„=*Bt-9BPùB2H B+eŠBŽ\ûBÂ*Bð‘ÉBùT‘BàoBÊ©{BzB¡ðBâv¼BÌ×§BÕ{«C"BéÈÅBäCPBÖ*0BÔW×B¥ .BVbRBMüSB É3B9“VB!‰‚BÕB5tB7B’AzB©1Bl›:B-XBCLJB:rfBpHBaø4B^P³B}”¿Bt5BHÄšBA ÈB¯¨B+aBLŒBP1ZB6iBE²ÈB$#‡BĶB1¦|B<¾‘B:uBnB Ö5B*ë>BMI¿BQJzB˜X¤Bª`½B‡BÁ B®'’B‡ ”B0BaœBh%BnšBs©ÊB‚\‹Bš/‘BŽ®bB_Ñ B>£ÉB5ZßBL³ÇBDÇæBT÷BA]B3?sBJ´B:6B6®B=@ûB@…„BIwåB²#HCm+C»9Bè’XC"ÜBù?Bzi­B! BGfB^ÜÎB÷zB°aÄB©1B’è—B$§Bd»¯BE­´BGý BK®>BB-*¹B<ëgBPBiϯB_KbB™,oCœ²C)‡ªC&mC0|éCº°BfÿB,€B'TBPŸŸBApB•4B)B¨uâB¶ ÂB­ðÄBŸ ßBEØB8q@B1.šBE`ÈBmÌÖBlË%Cy0Cv9CyRC’‹Bøs43C/U¸C:B€8óB- ýB$àB(BxBî©B5¸$B#‹DB4¤B#ÄõB-gMBÇB,¶`B¨B!ÇXB"!ºB-ÔêB¦YBz qBcÍ9Bxš6BrFBpûABÍBÿøB,~Bšà}BÈUöBí+¿B÷ÎÐBÓ=B½giBFnB—¡¹BáÞBÃn1BÓêBþ™BïÒBÈ@BÉÓB¾lwB´yÖBQ B-êB0B6ìËBnÙBœwB&„ÍBèvBŠ:7B sB…oBFEB9FBD|ÊBRBzÜBpRB]ABDðãB7³B2ŸÞB @B¥B;GTBB÷=B9ŸB1³ÕB%ÀB—ÜB)ö~B"5PB"]œB U‘B5¬äB9c¿B7=õBRÂ…B áÖB¹*×B™NBÍQ.B°½VB—½ZBKõØB"Ÿ-B@ô‹BƒÎ{BurB ;B†âuBvg3BH€DB!XAB'`{B~¥BoVB3‹ÜBN‚ºBBBIƒâB1ÑBIÓ°B5ÈB'“qB2gB³ýC’ABç° C•CCÆBè'[BwìŸB7$ BH×ÄB@%ÐBˆ¬¡B••B€ÔB‚4bBŠ]ÍB…œBhýŽBFØB5àùBzšBú¦Bf’B&@BIÅDBB)2BžûC3;C*…ŸC'˜ÔCÝoC,Bˆ8IBýB/øzB/JpB>ÐwB%[B¦cWB¸E±B¿¥1B±æsB¥ÜºBKþBMÅNB"þ^B*¥ûBrŒªB„»C ÍC ±QCIC[ùCRÔB‹•ÒBD;öB9R³BºB°NB6wïBDÄ€B">B©!CB—LÚB›ÇöBŽù›BBÿžBI?Bi¬ŽB*ý{Aá§B$»BQšB^¡£BkµµBWj‡BEc(Bm¤æBÅ‘B# üBeÛ¢BœBŸoŠBÈ‚jBÁý0B¯ÜVBÉÊÇBÿpfC9…C@Ù·C?­C2Ý­C èdB|ØB] ÞB(3B-v,BWýB2ÜB'ª…B*¸@B.FÓB”ÿ–BŽ<0Bpƒ€B6˜‰B,¬ÅB.çªB@½ÞBr-„B_8mB1:ŒBIåæB'¤¥B8iuBDCB?©9BT\?B*cB3BÚTB:‰°B²¶B-”BK7ÞB¦îøC¨tBÿCì™C @rBÀöiB]¦ B\[BóB:ð’B‰·©B†Ê%BŸ#MBv WBW‹B‚3%Bcv•BE¡B/Œ;B'oPB+˜²B?³ÍB$…*BTÉB:#ÄB£C–¯C/ÙCžC ›C\NB„±›B>°/B)ü2B8ÌB8WBƒF%BųdB¿ÎCB¦¢ BÃøB°’EBkžBtƒõB |ýB0°ŠB#¸[B‰¨ÁC;$C´CË{C4ßC fB}èÂBIýrB->ÏBé¶B#[B9pëBIýrB&¦B¥Ë$B‹gdBšyBˆÏsBT¿B-²2BC ›B&–B#É©BAnBC ‘Bc²2BUšƒBCV‘B9‚:BFµB>œB!zQBLÐ…BŽ nB§EB²åvB¶p1Bµ¬ B°þìBü"ïC2@C:ÓFC=·åC&_xC¬]BZ—B(m)B¡B&B90B5úBH±·BžÒB#ÓGB4,ØBQL˜B(îB®™B±`BXB BlrBDbÖB^ªBiš²BoVB‡nB`ÌÚBK¾|Aÿ{šB&‹nB$yBȲ7BÝÆ[Bè#BܾåB´DlBš%æB¢.%BƦ©Bâ*ßBɇ®BøCBê¢BËhíB¸zBÅîB¦¹ Bb¨ÐB«B.ožB@aÖB#RoBvTB(ÚB.ÚYB„w=B”†*Br( BQ´kB8+B*áBWÔ9Bi•B;û;BRmšBÀÆB5?ýB7¿B czB-¯¾B?IB'…bB¡B+§B2B 2ZB)œB3œ±A÷0_B,ò¸BóBh-BÐB.“#BvaøB®^ËB°úpB­Ë\BÄ3gB¯Ð«BE™´B é=BNÒFB~½ŒB‰?žB‚XPBxíBmK7Bf¤VB4CABPmB!!0BBEBS¼ìBEGBT\ŠB …BÄæB OeB;ÛzBEÑBW"'Bž CÏ}BéúBîu*BïwÑB¹Æ.BC[BEïGBêXB;…BŽÜ&B¢¯žB¯ZfB‹;ÉB‚BxrúB]kBD(yBQãBHB;ؘBJQdBH?–B1]éBG«‚B™s®Cd,C#„Cè)C%jCÊB…hrB50ÀB”'™B_ íB˜Ì5BøIÐBú øBýÁC%BܼxB:B2G9B+¶vBF¹ÔB‡P¼B˜ tB¢uFB”M?BšTBxðšBH¿"BJþ!B,½ëBB)B9NBB2"°B`PÅB)·âB·B°/±CŠC'3Cž+Cî¤B‹@BÑB0C×B*§B 1{B!B^þOBhùB£Bž0~BŽ*”B‡“BxÄ_B0bœB 3BøBL#B5܈B=?ßB\âäB_gBT¿>Bd.1BMæ\BHøÓB/ÓWB9XÖB“º"B¢ëB¿!)BéîXB°škB¡CÞ—COn}C1\¬C4^$C8õÜCþBBƒñB,qõB*¸B. BTB*ŠvB>B,‰ B3Î’B2,MBRÐBªBhéB v¨BùèB"žB5þB;WiBl#¯Bj®œBdtbB~ùÊB{Ä£BN«zBü«Bx¾B˜rMBÓkÜBÛ¶sBï`’BÇÔB¢ÉäBröÌB›ÀtB³™ºB®Ý;BÜ%ýC9cBô5–BÖ´>B§ÅÙB³>aBl2BR“yB:PB%ôlB?ë†Bë®Bí?B0rB8óàB‰±B—=óB{¾XB%:|AêñaB1ÆÚBX`žBOõœBGÏ®Ba,‰BTDB>ÐéB6Ù BOB;cðB6>BFoB=ûçB,sB>3ŽB8pÒB ZBa–BC°AítB3wB*¢B/\(BýB&½B2z;B@B3‘B6¬DB­Aí'B­ÞB©!B¡pB$AÚB3/B#7‚B€£ BtàCB…YàBu6ÍBOyJBCêB>QôBDâ¸B˜ gB²ÁâBÞøBñ‰õBìÚqBªäBnôâBK«B²9XB´OõBì—BÿWBòW?BÍ8cBÆÛ‹B»vºB †BSþB$MdB}SB>B´ÝB DÁAöœtBæ«B†{"BŽ WBm¬uBB½†B)Á”BC~bBBuBDX0B4Ì;BpRÑBiN¨BCœB;4ôB*Ÿ8B/ô’B!÷ÃBEÆBºBB+ê>B(âBDç&BcB(“WB,1?AÞ]gBºþB3t¼BqãB"xUB€ BÖ#B¤îÜBÂ*BªükB~pB]h~B`.BrlJB³—BZ+BqRBƒ2cBŒ+Bƒ™B<ê?B$Ù¯B/•ÁB;èB+d®B.;šBA³>B0|†BBƒåBDÀøBIž)B&—ÖB‰÷B¨3ëBî¦~C+3Bê|%Bï±ÌBÖ¬ BcgBGJB-wsB!uB‚׆B›"½B¦ÊbBÛµB“ B„ïB2£|B1B5qB3®ÊB HuB ˜ÈB ŒºB âÚB?›«B™»šC*ÖCô C$ñC$pChkBˆ{B-Á|BGñQB6Ä6B=Ë>Bt6B±‡jB¢[KB’—¹B³é‚B—°‡B+ÛéB(äLB3ÀB4Ý­B4ØÞBd›ÂC¢:C é/Cä9CÑ•C‰çB†ÏB ÄQBF¡½BC±ÒBT- B*4ÖBiÅBˆµìB•ƒBB–ò%BŽ8B=N?B"…ˆB"”ëB_˜B+å†BGè©BbBO§YBjØÞB„.OBj}†BY„XB*¡}B,ßB@òïB†³ûB™ 3B£ÆÀBÆä¢BÆÖ±BŸ8äC.¶C=DCV>vC;ŒXC?CáB~”ÈB)8êB ¥ŒB'Õ%Aä…ƒB ¶[BCnƒBSöB_åþB$ÏB èBSB&5ÂB€B8ã{B³B.ž¤B yBe,óB‚tB‰šÅBjZèB[aB ‹B6BgB+0ÂBœ–ÚBºærBÓÝÇBÜÞBù® B¤ÅB‘"¦B¦D»B®ÎMBÊkÿBá,CyaBèÖƒBµùàBÍůB±@CB±ƒ‘Bo ÞB.Ï®BµWB.¬B,sB(P8AùîDB‰ByôüB‰¦ BçBfu»B:J)B_îMBd!Bg_ØBp1…Bxê?BpBÊB5B<ÒÇB*k±BLµB*3B'«mB,óXB4̃BC^ BT_=B ‚B7‡ûB,€5B …}B@RB8/äB1YB/4õB‘óOBÁòƒB b2B¿ŒØB­{ÛB—OmBqi«B"цBg ÓB†uB€ógBmýµB‚c1B BeÔBSšêBBû(B>B‚BJ“bB74B2¹¡BF—2B4~ƒB/DB5v—B:unBJíÅB< =BeCÐCOÿC„BóU‹BÈ­ÜB^KrB:ŽnB3úÈB%õ_B‰¨?Bœ/B AÏB¢¥ÓB  B}íB_…ßB$÷†B(ˆB!ŸÁBE²B0ÓBatBJbXBGÔ€B¥ \CC-Cø-CyŽC!ùùCx†BUþtB ´²B'£B"¼_B4'ùB„B›‚mB‰.!BÛCB¯·}B‘,ÂBEyžB?`B&ŽAB ÿ.BZ¿ÂB˜3PC¼ÏCaîC³vCGaC°šBФ+B:°B7Ø4BCÙB lBLB/mgBŒB†Z“BŸ™ŠB‹ ’B‹×BGÈB8kQBœMBE2B-¢B5A´B(¶BOÓœByQBƒCBƒ“ BPVaB”®B,'çBWÍêB•‘GB¢ó¶B±ä8B¾{ÄB¹u·B¤ê˜Có€C9ÑCJT¸C-€°CFø%CB‚åOB‚oBPº0BRìsB,FB,nB.ÊûBI¢ÖBB`OB1°«B<“ûB IÄB=6"BF‹BB#f$B8£B5ÓñB ’°BòPB/©•B)ÄPBP.BµÖ¬BºfÙB£’ˆB¼-ÔB·ìhB’ÚB\±ÂBû&BU:9B‰ËÈBŒÀB“KB{Î)B|€ BbÙB[a8BL×B@I¨B!~üB ÄsB3ðBUÁÌBWxBBDxÏB+mJBD†FBM"B<çQB¨âæCBäiRC BTBøƒñBÏ8UBM5WB-³ûBDöÅBBß2B‘døBcBš@ÁB™ÕŠBŽY¥BzÿnBcBvB1ÃBMhNBGØB@ØîB%2B8Ü´B?ÆB›ÕCxˆCvjCCEC †ÝC%Q÷BeŽBmiB)I6B$óšB=53B€èOB®ËeB‰¦B·S B³üB0œ5BBB“ÕB¿©§BÎ-‚BÅ$ˆBІwB¹Ž­C­C6Ø@C=#ÉC=F)C@°êC âB=²3B°8B&#rBà¹B»CBNhBGñEB?$dB g.B,¹ûB4T!BGô'B)ÞB,sÊB3°«BëBQ=BfaŽBR¼¹BƒJBqð4B~>2B‚õOBD( B%%šB.ðSBœˆãBÏ"³Bá³’B×o²B×®¬B»­BŽQyB°(êBáü+Bê'‚BÆ’eB÷o€BÝ"XBÓ÷B)2eBa­BUÃüBC<ºBE‚uB7L÷B<»B5LwBR%B¢`°BðÐíBäõÖBóïzBû2œBæ]îBTa-B4²B „ÖB]@SB‚uB¬¾ B˜íB— âBˆêoBŠh*B[u¬BDAMBAõB<'BÈsB%g?B. ÇB%LRB1Ú½B¥ëjC¾C)58C#­CÅÔCã&B”ßB=='B´TB£B/ŽGB‘óBÄ–B³B¸¸bBŸ‹°Bˆ{ÛB.d4B0ÛîB tçB9 BXB‰b%C›CêJC@ CKuCoB~ ‰B³BDÕaBBËà²B³’C ÊóCAo^C+{0CO7¹C?~CcOBHýÍBåBGˆ¹AücŠAåÃ@Bb´zB=?B>7&B1÷•B8xB= 1B#†zB&Ó«BEtB2÷ZB óBOf-BDS’B~oB²ØBn÷äBe B—žBX0,B{BC¨kBAøBËsBØ›ÓBòvBÝÊCB­HýB{êNB¤âƒBÞÓ¥BÕépBÕ‰ÅBó„¿BïÍÊBÔüçBµÃ§B¤*`B’°ZBd†ÒB0˜ŸBÔSB:(±B)ª—B1B[]yB*[4B!ü«BY,,B‚2Biœ|Bdƒ•BWë³BE"¿B8ý B:»5B8XBQó=B1ÙB+düBS¨ÄB;û­B[»€BEW…BuB)£ñB[`YB›LB,ïUB9L¯B@%«B3ˆBîB£µFB™û…B¶åB°þîBƒÅBCÙB)kûB9qäB”7¤B‡ÿB¢G'Br‚BįBZÀËB3÷ùBHB5>B‘B?Ü2BYå‘BU‡BCÂEB,="B@mB>PB27æBHMºBµQBñí÷Bñ$†CÀDBùObBÐ…•BAq÷B@²B½ÌBM§ëB‹Ã9B|¶B™B©i–B›È-B=öB>sBQ%/B ñYB@­ÏB! éBŸuB;ïdBD%OB=º BµUC.œC&®Cã–CǶCVŠBŠ×+B>®B,:?BHÊ»B+¹gBŠþBÀ%ÄB¤üæB®ÇB­êxB‘Æ)B-¶AÛÁB KB)ƒB&ë™B‰·«C ‡C ÚJC 8ÊC ÙBýó\Bhb5B#ä™B6³ùAü%ÉB!27B,É„BF§B•± B–®äB²CîB–”rB‰†¡Bd¾{B.}Bš8B#B šKBÑBJ½ÄBg‰ÝBH5±Bl—!Bk›5B?œ¼B3ùBF²1B2SÈB€”B»:'BúB·TBÃ)fB¯ABC z¢C3ÁèC3ÃCPsRC:XqBô\BseoB!_iBc#B6~ B$®†B< GB!Bá`BÁjB òÁB=Ô÷B9mB<ǽB(ÊB#Î|Aèb/B?ãBF‹»B™*wB‹%ˆBv² BO~B~RŠBM¡0BÖLBZ3rBš¤YBÌÿ©Bß, Bÿ,WBð>Ÿ„BQÆcBUÓãB)ª%BVíBÅB‘t¿C¥¿C¦Bþ‚vBëªoBÇ76B2ü®B&œB™QB$ÅDB†‚YBžŠAB²–ïBžºÐB‰RŠB[i±B »åB-Û8Bh'B8£ÊB: {B½ÈB>"„B±2B^ ÄB¬CeHC?³CqúC!gGC WBh jBø•B$Ë B-Ý$BæB‰+B¨ÉSB£wOBºÑ©B²†–B…zãB@µAÿ3ÏB8”gB!äBGˆHBŠb,C¸ÖC{.C ÝÒC3SCÖB:À,B%'WB ØBÛB=qB/ÊiB${:Bt˜ÊBœ$ÌB£üB…ìÔBŠð{BN—øB$’MBáÎB0w}BHÑB#wœB;ïBMã3BPwB_oBm_B;ŒB2¿$B5dB¿§B•aB«`ÉB±‚B¸£øBÄ6vB”4CAC40C6ªC7òåC*råBè•BcˆˆBoÝB;×ûBA+pB&3œB$Ï×B1ãéB4ŸB)€ÍB/ÚÁB<"B.EóB=äúB yBYÛB*'B(HMB‘€B€R8B„JBL3xBK8‚B^7õB*?/B :ÄB2KÁB›¦[BÂrŠBäãÓBøÆ2Bíš—Bµ%Bƒ B­¯¦B¹ÍBÂEYBÂT@BêH—BðYxBÀòB¯¥B­ÞÄB¹”ZBR‚ÙB(x`B51BBlB#À°B& CBKn[B:ÀBc'¾BiP.B~!-B[&FB2»BU¼ÆBv©àBMÅÝB<]BZ}gBEz„B'½ðB¥B›{BU5|BJ½¢B8PËB!ä-B%†áB$JB#8ËB.slB1ßoBT B<¬­B+¾«B"\B4pB9JBB€ÿ4B©jRBº1“B§=¶B°ùB†FÊB$€%B#°uBS€ÏBY3uB„'†BƒÚB‰*±B~(ùBF4øB6Ü"B<ä\B®µB+ýsBN,cB3•­B>ÕzB:°æBPÌB?!B!“B;™˜B?!B¨oõCxBþ›…C BøÄTB¿™EB[õB!ìˆB'd‡B>vHBn BƒJ^B°ÔƒBœ¦¨B .B}&RB8IBÿvBEçBO B:ûæB± BX±BRÚvBHÚBªã\C3ÊC¸@C¿«C1„ChºB€ƒËB3q"B7ñBVDB!ÇBt‹qB¡2B¨¡õBÔ¦3B£× B’÷WBP`ÏB"ÎBÇ1B)иBAb\B‚ªFC|ŽBþÎ{Cº±C[úC @,Byu!B%›ÌB/œ^BÙ¨AòmBDÊxBÒBŽú0BŒx]B—wBB‘«B‡¡çB+×óB#sàBÂ0B%}þB?cBA·ïBA˜4Bl¿KBtB_õCB]£þB7¢B®¾B!ç¹BB BŸ¨^B¨àuB¥DçB¿’BÊ¡ÈBŸmCº1CD;cC9’C+*“C0NpBýðØBI"øA÷^DBRB/·KAøB ±&B*WVBǧB'š`B=¬\B;L«BïFB Ÿ×B"¾&B!øB=Ë!B}žB%€àBlJòBˆåBm¯¬BGp[BY„:B.«B%QÃBKõB’ŒœB¹×=BЩ BáK±BÜ B»”èBƒò£B°æLBÅ»BØœžBІêC’ÇBýÁ@BÍ%ˆB©Ø‰B˜àÌB¨ˆõB\ÂÿB7à¶B ØŸB€BÓ;B ü&B¢°BFÇB„'~BfFÕBŽ‹1Bh„œB)qbBF«yBukBUzBGßwBoýÔB?‚B)ä†B9hÍB0ÈBY ÂBZYB=ÓB-@9BS-BùB*Y”B=ëB Á¥B<ëBJÍÉB0#BΕB'ùDB=ÒBŒzƒB·³TB ƒBžÕeB°{§B‚ÝÌB{ÜB%•;BI…5BmÏ’BjöºB~?AB|ˆËBt¸ÌBbvBaZ(B1ñ¦BdB,¦ØB%'žBjŸBSB6.BB;,$BNÊ?B1uBMËpB8Ç¥B°zBöÎùCR3CuýBöÅÖBÂ5$B[²BEZB\ÆB5‚%Bp<¹BŠä™B àBƒ„$BŸHÇB…›=BG$ŽBEoBW’QB7¯BIæSB#”B"rZBSà*B:ÕB¢tËCRC'~TBDÍÒBO«`BAôœBFyÀB\š‘BLQ˜B øëB6ŠøB=éRB%½•B0sÍBUB3-YB;Ç_B;ׯB ,¾B&{Bp"B0©ˆB;T›WB…C°:C%”/CÚC"×´CújBƒAB!H¡B+»ŸB6¤ãBW)ÝByp×BšŠ‰BµB¥×ÌBdWB„&WB[‹BÈB?6B«¢B?èB˜›XC˜xCÆ…C²aC9,Cn¹B‰‡½BhB%U*B\ÉAÞrŽB9RvBRaÔBmRíBž;ºBƒ‚fB“\B‰ /BF®¥B>6B(¾>B eLB%åB$QBB6kBUÓBo®ÅBwu'B‚’~B~SÍB èB:BI‡}BvAB©TB©®øBÍOŸB²:vCI(D HC=‰ÒC@7(CDnC&sBC šBs¸lBFä}AðÚBàiBÄB?IaB‘uB-CîA÷íB+ódB2OBœ-B.ádBONB'8ÒBÌéB0ЕB%6BIë}B€à×BV°¶B‡YBмßB!å\B·B#¨RB‡g‚B³MvBå{–BøàõBÕïNB§Q4BQèB¸{lBÚc5BÍãBÖp'BûŒBÜØ B¸Z»B¹(úBºíaB’BMF$B;èõB‰èB k‡BNÃÞBFtôB0FB*iB… WB•̦BoOïBJ>™B?eB;¥dBGù&BTÕ&BB¯BI†`B\¬fB*¨B í3BðÛB4t"B ÁB ñÎB!ÞþBò!B*ÀúBÎÄBN…B$ðÐB*¾BHpBNËjB(®bB.ÑB%}ÛB‹š×BŸ’þB¨O›B¶ô)BÂ`1B¡+»B9i´B,$™B„_'B‹^úBkbñBuÕïBo­B“„ŒB%¯·BL'ÅBCqB~»B B$àB;VùB"ŠéBÒ:B0KB2¯˜BÀ½B*¢B5ÉB—ÇäBß\]Bñ¨BôÄ(BýÝ{BÕÉiBaeABG®”BAž©B"¤àBp'!B)åBŸVûBƒ‚{Bš%B…§BèWB9ª!B‹ÍB5%fB'_rB$þËBz:B7å>B+Û…B§jÃC$\5C"æ¦C«hC&O÷C‘áB…µñB$þËBCø rCFô1C:(C.„C !BI±öB[?8B9ÍB? B±ÚB­0B '2B-S{B+s­BDùPAõ|óB$*LBä–B ÇôB˜ÄÆB¦q?BÝ;§Bá@úBØB¢8B‡bB»gB΃BÑJsBÒëFBø} Bå œB¸1óBËÌ4B°{êBŽóRB}AîBSF×B ­B'›B2Ä¿B!%B#.`B%û­B‚Å B€ÙLByÁqB,ÌFB2 ªBL{ÉB\óÆBZÎB^B6~BwaBD ïBççB­Bú¬B,£úB'ºB-P¯BE¸ÞB<:|B <ÕB-j—B¸KB&B$K2B"û`B9‡§B%2nBS õB”ABÂÊB¡²DB·­BÀ, B‰>B:Á‰B0±•BOí¶B“µbB‹žVBU gB‹´ÕB˜ºzB€-fB”)B’ÜBrVXB2ržB1Ä”B)GB‹ÔB.º²B]½HBWVÓB6í»B2›÷B-VîBMå†B()îB/«B6æ BŠ«îB–âB­;üB½)aB²žC<&ôD£ò¿Dý> C@jLC;LrC-`C‘ìB<–ÄB#6 B)‚BVéB&ÑB`üB&ì BjçB!•RB9ñB!Bì¶Bæ­B$þeAÇ}/BˆBýB+ÚB8-ìB{óàB†kôB5~lBTÓŽB+ÞBC¥~B;@uB•K'BÆŽ©Bç\8‹B0±B­žÇCJCŽ&C è^C(’íBE,XB(TB8ÿ B9Ü3B3ÇyBßýB‹ÞåC£÷C°C!^C*´CìªBy˜BEéÅBvB_ÎB7\ÈB‚vB¯”³B½‹±Bw6B±+éB£7ÎB5©4BÞÌB5*B''ÀB 'sBˆ/&CþB÷bÝC'C|ÝBé=¹BqÇB.–¡B¦±B ¢B#žB ›bBx‘ B—»mB§ÿ×Bgw,B‹&B‰9úBQ„ëB%¸rBQ(›BH,B KŠB.ÛÝB+qB^ï†BjTÒBYª}B^#­BcbñBã$B ŨBRG%BŽ`¹Bà€B¹ B¥hÜB³åüB˜©hC£»ÓD÷§ÛDYÀC=wC;ÎC¶[B_Ù-B$é·BïWB*ç]BA8ÏBsÖB5‹fAù—BÁ†B2,æB3WïB35RBv}BŸ$Aí°ôB!¶|B4ÃeB(ñqBN5ÍB‹ ƒB~„BgûÝBy³mB7­ŒB9`)BBÍžB«r‡BÎ ®C–Bãq—BÊè[Bšš B‘G‚B¡ù‰BÀÂIBÄ3 BÏÞBÕ/Bã¾B©oB¿IB¦?ÃB”LB5"—B3tÈB(¾{B Ö B4¢´BBB%B7€[B€R/B„éŽBf6B:l[B0wõBDž*BD¹ýB;äyBPE6B^ž"B6sMBRŽ€BN {†BQ>BU«BfÇB$BB2ŸôB;B øB8¤B—¥¡CÁµC×HC˜ZC.BùÂßBrÅBDrqB(È»BµB-vBf;B®Y'B«&gB—qµBšI—B˜ºB/×B&;B/Æ&B*=ÏBB…µUC&dC"C‰7Cÿ?BòÛBL+\B*pÅB&­OB!¨BÕÑB¡!BC•JB¥ÿ¨BŸ7 BšÍÍB˜c‰B’2qBIõúBCÿB?ØBPVªB"o¼BGçBÕ„BhÄB€¥B‘,çBI‹?B{ç…B?ëÊB•·BOÈB£ªB«À»BÂSBº¦/BʧÅBµ‚ÍC7hDVš'E4,C:àOC:taC×þBXo½B'vEAñ”rB:¥ÌB3\jB8>iB2ަB_5B=¿B<®óB-–‰B!C¼B1ÇœB1WB-ØâB)flB¸½BIBd@»BвBsÖBtM`Bc¯‰BM°ÈB)MlB+³ØB¡þ.BÐ%‰C$ÇBó5yBÍ+ B¹:¹B…SBB±F«B»êBÍÝâBá_$BØCåBû¾B¸ª~B¡…B¯IB¤óB`àOBNç\B¹BÁ\B9wßB+Þ'Aúî¬B>¬Br*´BoBI†B:ÐB)ú÷BKÊ‚BGOëBb¤By BQŒHBJ¬”B,JB= šB1†jB¤ Bö†B¸LB#‚äBwB\ÂB>¨vB ÍZB,»;B#ØIB/K…Bq'B÷)B‹„BO*BLBÂöÇB’0»B¦DžBÁßèB‹×@B)x'B2ÃBGð!BŽÒ;B]B‹¹íB†Ž_Bs›éB2;jBsøB9åéB&_ÙBFäÓB)BTœ[B,³BFûB3*ÖB.½0B —BúBÊBžk}Bö¨ÛC¡JCMC SœBÎåBˆÙB%ÅB+¦ÎB8N8B‰'FBËÿB‘»B¯¢B¢ÿBZôdBA³üB@KB8š.BR™B0½°BÓrBáPB'OB!̲BšòB1ЯB ÝBàcB'°bB'-B6ÖB"ƒcBänBB B ï"BZ B#pB2zžB<Ê B“Ã|BµOqBeXBÇ$B¶ÀB«¢ Cà2CFUÿD,ÍE rD|üCsrBVˆhB5 cB9æžBCBZ{B,‹dBªB¼rB¨JBBtçB0~íB*‡ B1ýBA{B>¹:B ‚8B`)ÈBZâÓBP5-BbÚ>Bƒ%+B:‚bBSèB B8ÀcB‚âÒBÐ!ÆBÞ*Bá{C@¾BÌMBŠ*GB˜×B¡ˆBÛß BÒBöBñ:XBä˪BÓu±Bº‰lB¡´´B†¯BJ©óB+Ý[B?eXAÿ¸B$üÈB,… BBôàB ôB‚:#B’ŸBh}‰B<iB%Ð>B*‘ÕBGí€B~XOBgNVBEÎnBBkBFóBS¼ÙB'@°B Ò1BtÌB—¸B'NBR BñÂB(†éBg¦B §ýB4ª²B)ä*BO©BnvB.†B ‚‘B”@PBší*B¬)0B¯ƒB³ÇB©Ã+B6Q@BQlB@ ŒB…©ØBS+ÅBÇ¿B‘s%B€ç”BJ²‹BQ˜âB4OÊB9¬B)2šB9JÉB9BK B9êfB%àBDZB+OòB1¦BW&ÿBŠ«C2gC ä{CClîB¿š€BOãcB'´àB!ßœBNaÏB€[­BŸ£ÔBœšB‚™ƒQB“XBåWB++iBr%ŽBóOC^$C C¥Cô+C¹èBešB£B#óVB!¤ôB‘PAý_àB7ñBÝB—0ÛB”“%B™µB—A3BV-õBëB#Ó›Bÿ¨B1ÄB$ôB`¸BFkZB\à`B;ŽB:îúB/ÿòB#XˆBÑáB7 ÓB• jB±´ÒB¡wžBÁ`YBÀÀ@B¤ŒBþ!0C2#C‹–D„Û@DçÍåCé³BDׂB9FðBâžB Ö B ÄBEB*‰B<À\B¢ˆB%f}B ZB&:ýBK(B4‘,B dÃB'©VB-ÀòB;ò—B? BA÷ïBUÍB^ÏBZ>WBXòœBÌÒB úÃB‹‚õBô÷†Bþ»Bô¨2BÜðB¯µÃB“‘ïB¦êÏB½h|BøVBÀgOBþF5BÓLÌBÖvhB´µ‘B¦‘ÝB’ 9BYéºBQfâBCüGBW2B(ÝýBbB0”üB9€¢BbìyB„*Bvb"B0ý7BHEŽBxLoBl¹‰BL¤QB< ªB]<îB?ÎBUŒB4cBiB*ÅmB ÁB6ô¸B)dUBÿB‚=Bf'BÊ B)]žB=æ¦B-ÛB8QBPB;êB¥BƒÁB”ÌÅB¶µB¥ïQB­$B‡­ªBEY8BP ¶B&–=B…D[Bg~‹B‹èZB…z4B©HBOh6BC/BU„BOžBJø£BbBI:|B4QB*s¨B'LîB"“QB6·BG†BT5B³<˜CöCy1Bü ‡Bùý BÈÀFBNº-B;VºB $B/5íBˆ½ÇB˜ŽÎBš£BŠ‘B‹ßBŒò²B1 1BI^B>?êB!84B«­BlB) ]B)~xB&)B>átB!UB— bB¯D@B—ŸbB³1BйxBB‰¯šCsÜC-iC-BC jÕCÛÂBuÛuB æB ñÕB.Ö¼B ÁýAØ?BLB›¶B‹€B‰†BBŸµBÀBD®Bµ/B4bìB˜BWêB7BP ¬BEEýBgd•B.mB4ä»B7ÌõB)ëB" B- B¡§*B­ÅB¨ AB¬mÐBÊA^B têCf(C+‡yC7¨ CÄ™XDþ‚‡D„ŸMB80B%µ=B G_B°…B A›B+®B:þCB"M AëèŠB# BšLB&Ë BGB=ðAæ…²BlòB!.–B2ÊBaåBU͵B‹ì®BRŸIBN…JB/I(Bd¡B0¨B‰}BÚ“>Bôÿ+Cç>BψÏB©Þ†B‡» B´@±BÔ<,BÝ„›BÑ:ñB÷NþBå.BÅN‹BÈ üB§\³B¤2›BD®B=ÆÃB4­Aþ]ˆB~B ŠsBIšB9Ó:B÷ãB…«ÜBg|BFy!BDÐB†Z}BZ&pB48kB: wBhèçB*B& ®B1 ±BB«@B8bB?ËRB/&£BÒB$¤'B1!BBªŒB jzBK·ùB€²¤B~U¢B“$DBÎgBŒÕ^BKìÜB.+B.„BÇB$„lB mB$ÀÿB:,¤BVaÇB:·B\±'B.ÏB+øB'þÎB ªBšóÇBšO×B©Q§BÅ=;B¿­2B¨ú'CŠIC)ç C9ÎÁC}† DrDÄE¿¹B®Ù BOB$ÃâB¦ûAÿ'nB/vWBz÷Aù”‚AûZ[B2ÞBøäBφBa~ BLY1BD®BÔÙB.½=B(ߤB&POB4lÈBA€pB,BE½žB/p©B+æAýíJB%Aä üB8.B5¤žB÷B*”5B6qBµÔBº°B–ÈáB¢03Bœ’9B-cBà=B#5BqäB‹ #BŒÿ7Biº±Bˆ³B\N)Bw,B-;;Bû*B*ÍB±B>YéB8!œB¢xB<ÈB #B.À§BHB½ÖB-óØB™nÜBÿ³C„GC"ªBô›ªBã«#BPQçB|ÝBã[B´ïB€L¾B…ØîBœrBp’BŒ°^Bo_áBñHB¹HBíïB3HDBD5èB |BJÝB5&&B8ÝBR§CêåC¦`C ŽC ×zCh´B‚RˆBNzB"‘BB>šBÒ*B·FDB¨ÚíB—BÑÏB“Õ±B)òÙB}B4&BëB!)BwB%C+vC=C§@C–C°BviÍB6ðBëUB$wBî®BopB:7BBy»ËB„UéBƒB’^6B‡3B9~¥B¤ÒB-%B+I'B5B(ùÏBÒŒB@¡‘BMç¢BVªBg·OB=®ÂB ‚Aà±wB$L³B‘³B ú–B²BÀ3ÖBÑ«uB -LC¾pC.²C&šnC-ò;C?à›DòÒEMbC°/áB ^ÁAõ|‡Aù $B)ÂÅByB&oB¶.B Ü{B)”žAîótAÿ:ÀBŠJB Bq—Bk%BB.®B^÷äBsaÖBzÿÕB¥ABl:B!¬•B-hlB@7ËB™QˆB×ÿBKÉGBDVÆB'½B6=.B($ŒB%µ×B>.VB, BT¿BEAóÚ4BÈB;BõlB0˜1B!yžB~uB+ZB* ÷B‹ ›B«F3B§ëBª|B—ĶB„:ÍB#B@—‘BJü#BˆÇ³B›zB~ºBBw…Bs”lB]°—B'@B5q»B<½ÿB¨’Bé¬Aü‡œB.ù÷BÉB+J³AóQìBÉzBÛûB³SB˜£ÉBñ¦¿CºBµ(@BÁ[BÎg6Bš+C=›C@ïlC3½ÉC=ž%C)Ã:CJDKSD¼OB&–ÛB1e2B -B­ÓB!7ÜB$ˆåB52EBY„B4cŠB;îMB¨ŽBAAô¨;BxÂB þ+BD}B]ÍoBƒÑþBhS©B~‘B€!HB$VåB2mžB7wÿB—U§BÑù¢BÙëHC=BÛÍBÈÔÆB‰™QB¿¾WB¬BáEøBÐþ1C?ªBýQBÅ7ÇBη€BÄQøB•b"BGD8B/bÆB,IB6|B†B$¾¾Aã@yAòwB›CLBfd¿BH›B6>3B2k†BRÿeBeŽÇBOÔ BFù[B;9\B4ßB.zB‹8BÄB2ÕB)YBGãxAí8BwB âBã{Bâ}B%«XBçxB/LEBBÚàBlvB Ñ*B=ÓB‡ÿˆBÕüB ðûB­AéB¡ö’Bb5B35)BB 'B P°BmÅnBš6qBжªBhݪB‡,æB[çB&rÓB0ÌÑBX{rB">ÝB4BB?²EB1xB+fAý3ÆB'd+B#¼˜B>žNBˆŸ’BëZC]ÔBôIBïlÐBØ[BWÖB!Î]BPBB.]½ByÓöB·ÑÀBŒenB‘ÛB•.wBf%ƒB<ê»B6*ÚBG@B v"B %B<¸»B>‹BW¯™B6çPBŸ¼aCÍ C–†CÚNC˜®C=WBTD™B&BPO$B/B¤òB[ý„B—&ÊB¶WÞB¥ÆˆBŽúøB¨RïB8° AîrÜB¶.B ÆçB=B‹éeCåC%CK½CôdBú1ˆBIª/BJÔB7¦¨BŠÊAÒ0Bú/BIÛ9BˆM×B“­B SXB}ÝB‚; B0x3B@¡±BƇBùÂBìB eWB/ÿ B]gBrÚBgȾBc¡B8n¨B5_AûµB$ßðB€jB¼IB® ËB³«¼B»`SB¥WyC¤JC>P£CD4SC9ýèC8’îBø8?C©¬E&æ4Dÿ@ÍB" çB tCBµ}BJB=ÌBš‘BW€{BO-B0Ô‚B'!BŠÎB-ÅBvBßBe&´By{B‡yB{9§BLA¥B`fBAò:B!¹6B4Ä2B˜±ûBÉXGBäPBÝrkBÑЊBË9†B€¹uBº_˜B¿;ÒBé BÄ CjBØ·]B¶qÔBÅL9BÃUVB’!7BeÚƒB%>+B#ÕBaB- oAë&¢B½BsÖB‡T$B4ÐfBVÛmBE%ØB1_–BhÛÙBZÀUBSì%B:9åBN¿BEØOB3ÂÈBB 2›B;²B*=®B]ܵBš™B ®bBš%BùRB-CB0IUBAÎñBékBVŸBX~B*áÁB-›B†è®B¢¡ B¥C“B»/B˜B‰ ŒBFr‘BGå¸B$]–BtB®Bˆ”=BbÀ³BVÑçB>|B1ØŠB%ƒÑB@~ˆB7SlBMAÕB B$IeBB„ÌBNÞTBP@B8ÓB% B/‚wB‚FÈBÿ‡›BøÀþBÝaÌBÿ=BͳÞB'æeB3mYB%›ÛBðüBpêB­yãB [¹Bç·B“ÊB†[~B+/¼B©µB(¦B.#BÔB!ðB)–BMÊB(=Bœv!C!yCÄC À»CÑCNƒBMHB sªB940B(ÜŒB!âBc*xBœB¤Í9B£‚tB–cSB‹uBB+{²Aý#MAØ_ÉB¬B4 B¤±ÑCxCÍÔC_÷CxBöZBMehBüËBMBèBÎB%<ªB.̼B’ÍBf•xB§‡LB– ÝBƒ64Ba{´B)Ó©B'ï BáðBèUAüÃ&B&–B[RB^Ú¡BW1B?M¹B.O¼B:¥kBõgBB‡GŒB¬œ¼BªBUB®ÿOBÁS›B°ÊqC‰+C5ÁâCA£vC:©*C4óßBø›ùCþcD¿ÕÉE›•yCÞøB 9ùB)ß3B+‹B †B°uB6ËØB`Aö`‰B×B 5¯B J$B X¾BDMB:qBw¤ÃB‚Æ/ByJáBg)B_«GB-Y•B>ÃB;„B3­B½dáBËÄ­BÕ‹ŽBÊ–FB¤œ/BŠì=B¡öÈBÅD½BÎIÞBècC!`BìéÀBº‡µB¾ÛB¼|/B(_BH‹B$¾B)ÜBÛ6B«ÔB"4´Bµ¶B¯¶BmnýBMäåBV>¢BGwBJj}BrXàBbauBeÄÕBE­²BU²B8,©BBÁFB9ÙB'pBc×B5e¯B$íBBD!BKB"tmAÿ0vB¼'AôÒ…B•B ¤ BOÑB7ˆB‡ÃºB—AÄB¦ zB»)…B›˜JBÄÅB_^B>mGB-Í„Be ñBot4B„C:BlåfBjIBWŠB*{B&·B‘B5h¡B/B˜B=QŸB0 ˜B!˜†B;TøB,>{B1„B+G]B@ûBšü…C{Bî=íBêO®Büx:BÉÈÈBNZ0BAîcB8ñoB“³BnæBšJ£B§åRB§¯yBŒw9B}Þ•BÉ0B6.B-‹,B3'´B+´B1õðB¯BD*B1—B©¾àCÜšC¤C±cCOÃBø:,BN›“B3œ B6LƒB%ÀòBÁÖB[ŸKB¡.B‡«ÒB©Û¹B¦õB‹“WB=¼ZB{`BY¹B·tBP ÃB“jBóIEC 8ÝC ì6C (LBûNB¦öAÙp AºäÔAý¬ñBnœBN]B+.]B‘Ø Bjè¿Bz`ZB˜á•Bä B/ÿBOkB<¿xB"-B5¶ƒB*„,BT8BPõ~BuÑBhÉBQ¡œB=ZFBb‰B ‚vB-€˜BŽåBœW(B¦B¼gÊBºcqB§º‰Bô…žC* C;ÅqC7Æ]C9LCÂB4Ù\C›`¡E#öDÆ##B1ñ!B$"†B+ü"Bv:BóÃBÎcBkÌAõõòBŸAþgB#NBà_BDÑB5Z4BR¼MB~£²Btb³BL ºBiØ¢Aí}B%;KB;¢ÚBÅ`B¹ÄOBíEÚBõBÉRýB¢¢6B€v£B¤òÿBµUBÊñåBØÈ2C$šBê¸øB±'üBª \B²›ŸB“HåBKÖëBEÂ1B{ÄBs8B¦B ÝýB J±B³.Bx‹ŒBjM~B_—FB<7¡B@ÐìBO@ÞBB2ùBCYBN‹†BBÅÆB4…ÌB É~B+ BŽFB*2iB+½¸B°GB«oB4ZB8W„B :ðB/A×ÅØAäÔ´B¸ŒAÿ/ÒB&) Aã`lB#PÊB–LðB®ggB•ó†B»jSB¤3ŒBR¥B-)ÚB/smBW-˜Bw÷ÎB‡“¯ByØ’B’0üBb^øBC™BB2tB&¹ÇB+„³B#5B10ŸBA¡CB<,&BIDB41ÙBE…jB+fäB4ÏBböåB£ãBCm!Bë\TBß¹BõSBÍ BZŠ+BB.Ú‹B<ÅÿBŸlzB_CÈB}À‘Bs¢1BœÂ¿B! æB=?&B!ÖÒB¬úB.ƒ BTGJB*[B`-oBDŒ`BsâB]}ðBV¿úBQ¸B<µB!IBžI!B»áBÆúiBÄ¢åBÈÕB¦Ÿ¾C±åC+]fC6®C77 C6½C¢?BABB]y!CÏZ7D÷ž:C¬ÄFAê\QB¼ÓB–XB|ËB ®ôB&¡¾B;B7­1BsˆB åLBw˜BqB%Ð BJ^ÂBoÃÏBuCBhöwB[ØÉB-w½BctBC‚þBœ¯ÿBÅrBø+¦BÜByBÒˆB£¢[B„KÈB’*¼B³œ»BÌœ–B€öOBpàÞB760BÛBO”ÇBfÛ3BCìÅBbì²B%_B6ïBÖB!ìKBÇ‹B&ØB1ÅøB7—B¡"BBLB$6‹B%Ž B¢¬AôqB‰-B7Ï´BHsB!H9AÿU&B%¦üBŒùxBÂOñBŠÖ¦B¶ªoB¤Ê÷B^FÙAù\—B'yBGŠ«B‹ŠB¦|#BƒÌB–‹ÜBS«xB7¡šB2³B4$VB8BÖFBJ”B&CvB,EëBàGB$â”B ÅúB,FB%pâB5ÎLB¦üBôã¸C¯»BôâGC°oBÚ´ÚBAÊB2%B"umB*ÿB€d¸B„ÑäB£FB… $B‘}&B‚RxBÉÊB^=Ba[Bš6B+Ü&B ÌmBº>BD@]BRÿ[B³z’C¼7C ‹üC ÆáC†ÂC B†9AúqƒB .SB*öWBË—B†ÑmB›ƒBžÿËB™g—BŸžsB”ÊWBúPB.f&BƒTB@eB²äBkîþC =C `uBÿ~#C –ÈB÷èËBs4†B©ïB ä„AìÜ™AªèBÉxB?K#B˜ŠBd› BÜ“B@B™BèB%ëöBA­¶B+0Be†B6ÞiB0TaBN¯ƒBUÐBa‰vBt}BVñíB„æBÔ‚B' Bž¯BÅë¶Bâ†B´ÜæB¶K¹B³±aC `·C;¢HC8žhC.‡¹C7ÅC!åBFÓúAöþÒBÊÜ"DD-DŒ uB ‰æB ROB6ÈB&GNB$]ãB#4ÅB=ÐB= -B±©B\QB ÕB%»B –ÝBH†˜B„ÐrB\(‹B€*BUQ•BþcBïB>èBŒÑöBÒÛ>Bæ®¶BÞårBîaaB¼xøBÔ@B†/äBÁtîBºÌBÔùBßu­BëÆB²¬ÍB¹ŠøB­÷ B§-ŠBBmBK AúmªB¨½B)’“BÿQBJ B.ƒôBuröB„Ô½Bm¯ÝBÝ/B^BF3¨BkÁºB)b'BD»‰BC0:B:¬B/ B2µ\B#ÒB/ûB1fB@*áB@HB!T7BõòB-išBìpAúqB„CB/ršBÎîBÒgBABAVBo$$B¯ŒüBÙÁB¢¤B¨èvBnÿàB @BûøB+ùDBsÛ$B¡%sBr¶ÕBzY£B=;…B  BB©B'@BníB ,B3-~B 8çB¿RB:RUBƒŒAàGþB©PB(!B+=ÄB©6BìJkBÜ[–Bã]ÏBýBÌQXBDЬB:ŽèB PBTîBc.Bv^hBŠ1B…äB–ÊB~8B*³NBßB¾JB$±ÏB¸îB<`KBîÇB4>‘B"\²B UÂC!űCé¯CÞÞCœ¬Cr B‚$BšÚB«¼BˆÈB3ÄsBp¥B•±ºBœ'B¢+xBžBw2éB"ŠÙB&‰Bã*BäeB6\ßBEÛBþãòC 'CtàC¿©BõýBzäB@ ÞBAeAöm5BJçBxFB.B€¥ÂB{ÞB~©{B£oB—1ÜB3g/Aþ‚BF&6B'ú1AúsúBÃFB8¦sBAœ­B(×XBo#tBAÆB6 8B"!Aô]B|QBжBœ Bþ(B±½ƒB¯û„BšTCCs¼C>7¥C1“ZC0XîCÍ–BûÒÚBE2ñAþ-ÒB>ZC$çD‘·~D5j BB#¯'BGJBR‹B·fB,ÞA檚BxæBµŒAá.ÃB¼ïB#lB5¥8BY`OBjˆœBXÕÚBU­3BSBGFB4I%BZ¢BË?ÉBÚŒBñVBõ]B¾OKB]V¼B‹¸^B¹«QBÏ[µBÖzÇBÚŸZBè*,BÄ2BÌ“°B¹L›B`gB?ŸB!ÊŠB {„B4fóBú5BìqB„ÆB1cBo€ÊBz7÷BW‘€B¨¢AáD>BM)B<ÚEB#Ê,B3pBSC B?C8B.”ŠB&*}B;Q×B!!æB*á†B…BÏqBp.BƒüêBg»BvGB>˜KBC'šB,Ë”B5œMBVŽB.©vBw¬BT¶ÈB3a&BŒB$ÀB4B&Bw¶B$'B¯´¶Bî3;BËâ£BتBøÁ%BÎÅB`êÐB'âÚBŽBu B‚#[B›µB™^uB¢ÕB˜‘¦BdçB) íB .KB!axB4uB)jB>pßBFHBDw-B@¨.B©’†CU—CCúC…lC'6äCJ…BoµXB³àB! BÛ BIƒ{BfFìB™­ÈBž5áB¦ÙäB”±BdßOB 3ŒB7€êB#'PB-é'B ;=B€*C_C˜ÅC ãùC6TBâwdBldNBê4B$ˆ2B*wB&HFAçÆ°Bý®Bˆ3B–5ÎB”ÙºB–ÀDBŒ,”B8š¥B °™B.õlBÛ¾BÐBTB;{/BDMÕBB'ÕBhœ B:­jB?}B$dŸAî¢tB«4B€ÍB‰téB°uBÆ„šB§¤KB—laBï¼C-)>C=HC3xbC.NEBøBS'¾B ”©BÞ|BxTDaqDèú¬Bâ)B(þB8Ù%B$ )Aú ÁB ?AÊ"?B& ÚB]AîМAé*uB2'°B)ðÏBIòByx_BMßÓBZBB5¼ÿB ££B.r§B› CB§ UBÝ3BÙ©BØ`9B—‘fB~ßB§ZB§i(BÒ¦BÐS+BÚïýBðÔÉBÌ ñBÄg¼BÚ!¾BB.²BÒSBeyB2.kB>[AüîB LB<åB„üB}úžBmV~B?ª,B8zB0…B_~B9ïBD¥TBb B))hB&GBmB%þ¤B3#B>BȇBÜBËB*˾BÌ=B"šMAîã˜B)8ÂB&3iB0:B`öB* ôBB€âÏB|¦öB³Ö³B²L®B‘-_BaÓB‘BNtêBk‡4BnlŒBC)“B€²¢Bam¢Bx›EBgo!B2yyB-`«B2'¾B0ùB>Ò B š|BOÌ.B¤9B<¥B*5B,ë\B'cB'+@B±ÀÆBÖÙBå` B÷içBðk…BÖŸ6BS ýB"ÎèB99BçLB~ÆBž™çB¢#0B£_‰BŒPªBR#8B:ÅBºÓØB¸Ê6BãœB½y@Bœ^Bó ¬C6y C?ÚWC?uÜC3„jC”PB9¾ B £B,íHB!9CrDˆðÛDYÇPB"˜BHAkBWÌBÞóB}ÃAÝ‘VBÊjB*›B ;XBÆ;B.BR?BLí’B_ŠñB[ÙÀBEkuB4[3AèÒBiB‰:ÃBĪBãêB̬•Bö¡B¦ùB„;ëBŸ½ºB™ªíBÂÙ¯BË·ßBêÊ©BñîŠBÅ6B­w©BÃW¦B™–AB1BŽ;BDÖBÛÂBå;B ñ’B ÀÄBîUBxŠBTÔBa4>B5¾B@bBCÖB-fBJ2èBy´jB]·ëB=(ØB·Bn¯BX„B!dBö'B –JAý´¢B/B7+•B' B[ÑB ÿBŸ“B#»®B/tõB åYB ìÔB!HBìàB™ŠœB¥¨£B¦$uB”÷ÕB~ˆ'B!‘BMBU€VB[²BfxŽB‡fB€tgBpŽGB^>ÊBa”B=Ê)B-ë«B+¬¬B5vnB'ÖñB·šBBcB#G£B4ªB7åBǼB-º¢B¨eaBå¥%Bî•BþÞWBÚEBÖÏB1ÚeB1$«B/µ\BgUB}öB‡gºB‰ðHBž”gB˜uBZ ÕB+ÌfBDL€Bî¨B–œB1n´B"i†B$…B-ÿBAŸâB¶S©‡KCG¸CI:C0¸íBü ÉBXcÂB B@ÀÏB+^ÉBTßÂC…ðvD ;¸CRãŠB~ŒöB4B¾Bá¥B.þB vÅAì«ËB̦AÑ BˆAB-$BNèÖB]ÓBƒä°B`S{B>‹mBX2BŸB~BKOBÏßBì1•BÐ8Bð$(B–°7B‡4ÄBÉÛBžç“B¹íXB¾ilCÉZBÙb±B¤ÜBª«—BÅÅB¦#úB@ B&ÜñB5þBüAûùBûÄBR¤Bå†BZöÅBZ@wBLö B?ߘB'º’BGïtBQzNBbã!Bn¿èBBœï„B˜ñBGò¯B0×B-Ç©B1wäB ýBš­&C ¬vC ¸}B÷¢5CC¾BX«qB Ÿ9B SB!:5BðaB0¯äB­B€MºB¤(B‘}ºúB ×[B åBz;B—RîC \§Câ‘C¶VCå#Bû>­B}óBÃÎAßñB-VAò­1B,k|Bˆ°B‹FSB’ ïBŽþºB“øÃB€cËBPžÆB(¥AþÒÍB2ˆÞB>‹Að•B+–B\&BpîÞBr­BaþB+Õ}B jøAøöB1a­B|“¡B˜ÂB¶ˆVBÓ„ýB²yàB¢¼Cì~C=žxC(<íC:1ÊC3"ÒBï1B@‡BGvBmDAý>õB1”£BþºCrï¶DèVD¾BkœB˜B+l®B8'B=BkBè BLBcâB;Ú1BµµAÖT¬Aù=XB+}B#XB ägB6B€¦ÀB¡YÎB›,B®$ÊB«üÞBÖUBF•¤B4NÎB;†àBZ›–B„ABBtȈB|²|BkGÙB!GB.ÉBB‚_BJÉ™BcÂB@oBåRBH ·B-·OBTB#¼‚B›5BHûBåB¬÷BîMÀBæÉ·Bèk€BÜ—$BÍä,B{ŒB-RYBßLB>n%Bg­»Bˆÿ3B‹™B‚€´B— ¿BUåÒB•ùB'6äB­¾B ]™B ºQB=¢MB+M B)æcBÍÇB°EûC³•CAÈTB®qBE¾ABŒŽ¼Byg8BŒcwB˜kBŠ“†BF #B/hB •^AðpMBµ´Aÿe#B5_áBDüBUÕyBlGB…’GB>0›B/<»B î>By*B„ZBB”6BµñæBÐÍØB¹eB¡0tC^C3PC5pýC.«C+ô&Bæ÷cBKÛ¢B²RB$ðBõJBdB/·ÏB¨û£D5Ð^ECÄõAû`KB-…OAõ›B¿A×óB B,»B!`©B`²=BPá5B[®–B_ö½Bu°BB3‡ÄBDùB= BƒÓ*BÉ΀B×Ü’BãÀËBÓ9BÁßBBl_§BšãõB±6]B¶ÕMBÞ|Bpj`B• kB¦ÙŠB’'õB‹JÀBW6xB#ÑÅBY³÷B$(OBxfB+¤¦B< šBç^B/tœBœ¾BŸSCpCÐCsËCAÏBàë_Btì7Aî|…BDƒB*–B-Be}DB–qB­çB©%B|~­B}j@B ÝSB–^B-ÝáB™@B%µB‘²§C¿¢Cu¢CïC ¹µBèHvBqŒÃAåÚéB ùBÏAþ•«BzBG—pB‹‘èB{]@B€Ü‘B•”áB‚Á.Bk8‘B6¾óB Ü]Aà±ÃBºHB"6ÁB¯„BN¡B˜ùBÀ·¤BÀ%B¿Í‚BäYBé¦ðB»EiB¹SWB¸*9BŒ©¶BG`¡B3èBÅÒB'B¤ïA­FUB Bž†Bz½-B„p/Bq^uB%AB+=BI£ãBfRBb¿BEqBBb›ÿB@ýB-ìB˜mBïËB ÎAB1˜ÅBcýB/qB;&‚B ‘B‚:BÄB›-Að†÷AÝs,B%IÐAùßîABó B™]BœÿµB 2BŒ (B¤_óB‰nÚB&†2B4ЦB,‡²B…á=BqÑ&B‹qFBŠZnB„ãßB9mœB:”ÍB,PãB>&BBÍB ÝB-ÅB"·B jTB7›CBP>BîÓB WËBÁ™B–üŽBÿÌ8Bý•BülFBöíBê®ñB8’`B'–PB\B/•lBB¡R³B›HB‹úÆB|†}B`V)B&¶FBU2>B0üB6Ä×B%CB,=¨B_åBFAAB=#›B›¦ÈCƒÐC@¬CœC :ÑBø‡*BmTB”‡B|¬BäRB>|ÌB‡ ßB•§B©´ÚBªFB‘(BŒ“-BZ!B|ƒBT¿ÒB4?¦BHB ( CÇÂBðκC°C hBýò.Bxs9BÐàB~4B B2BBCUB")ÛBœ|?BˆB•ê„B•(IB…‰½BW™ BPoB;ûBå¬Að#×BUB4ƒëB8 êB1ÈâBXKƒBS—«BQì¿B6B‰KB ABаB¾t`B¸ŽÃB©ê²B°ðJBžùC .TC4‘øCF®AC>ZˆC9.úC°ŒBN{B4S×B+Z»B JB«.B"_Aúé‡B†ZàCÌnlDà´ÏCËǸAãøvB¹RB¨ÝB¿‘AÜ¥xBm_B:¢CBR*IB_(=B‡ÂøB‡6BsDMB\<*BejBa„BškfBÕ=ˆBà'ÂBÞ9‡BØØ!B§Ä7B`xÆBŒ|”BÇóžB´ {BÁÃ}BÒ$DBã–™B£ø–B®ÓèB° öB•B<êB2^âBuLB)6¨Aö£LBƒtAÂ4AAì±&Bƒ–B‰Æ"BU¨=B8CïB‰ B/ÜÃBEÀ,B_ ÖBAq¸B@NB]ÒAó{‚B(ÈJB‡’B€;B §íB'3bB YnB&Ø!BƒTùBYåB¿@B/UEB!ú B:âôB&ЂB 5*B(—PB:JBPˆBBSB%šäBLá­B2B%äB£jCgÑBÿåÕC¶BÞJ}BàÕîB(Z¼B®ÈB,¨BIRBˆ\óB¯ùÊBˆe›B‹.B‡°[Bb\³B¬\B.æB6B8kB\ÉB%L BNÓBhBG3ÕB¨ .C¬Ck¼CŸþC‘Bö +B^j B šB(¨ŸB-šB7—°BkW»BŸ(þB©J½B®¨ÅB ªBŒÌ B> Bm B#øBG2ßB9(¦B”ä'Bú(›Bì‚ÝCbC mŸC,ˆBe£(Año&B‡ÀB ø-B­$B"[*B-6÷B˜2ÉB~ã‘BŒ…_B—¬§B—äB7Z&B-B5B7ƒAïT°BŽšBNó{Beä‹BJì¶BZÒåBFlËBOýÓB4XB-Ø€BjgB‰ƒ.B¶qŽB¥'›B¢Ï B¼oB®‹qCZ¨C,G4CE^C,¨C<î-C­´BCFB!snB*&YBãjB'èPB"ð4B ±B(ÓBßÿDXå5DðdvB:ƒB¢ÞB BæÈAç=‹B,{wB ÒBDþsBadB=áBU•BSÚIB\ŸyB­$B°BB“z#BÇ»BØ/BÐnçBØç¥B±¯ÅB€‘HB“@B¾CôBÂÓ½BØúfBøY¡BæÊrB¢€ÃB ´B¯³˜B†r‘BBšÍBÍ6A¾;~BuVBnîB_?B`äBH™B)“¢AúÐ#BG%B6‘8BRäB:Ï]B\<B©ÒB9K»B ˜‚B*_ Bº_B%^!BqB!úÁB4ËbB4bÍBöýAØ”-AñËœBÃB þB!…²B½BFÿžBš ÌBªMB¯öB½¼BÅ›hBx©B={¢BiBBbpB‹ÛÊB’¾HBc'×BzB8²£B<1ÔB#–ÎB9AB&†¹B:ÇTB*í¥BOÏB1BvB˜?B9@B!ûDB ç—Ba×B‹c˜Bøu)C ÚC®†BàYŠB¸ýB%HuB7˜èB+íjB'”ëBŽ<ìB b•Bƒá÷Bš.BSBc¦B(ÝÃBÇÆBFB»³BAðúB B#vB)§¯B*žÌBš: Cˆ.C ý2CÚ4C!ãBú íBh™B#ˆbB0=BB.û%BûmB€‹)BœU‘B®FWB¸ÿ BŸFíB…VBFx—B¹ÆB#š§BcBŠ»BˆvBøhC ÆÞCŽlCòÒCä(BeAÔ+`B=!BÓøB Ô—B;lB@ÀBˆ^ B‚ ÚBƒ3îB–_!B “B.'›BÓBDwB¸lB ıB-újB=ïBGæBAôÒBUåžBB¹ðBM•½B.^jB‹–B,tB­†ÿBª.EB±nƒB¬ÈœBÀ]”B¤OcC°³C1GŽC9-èC'‘¾C*—ŠC4«BO©B•ÓBYÑB Bj©BñùB ÙBBHÊÒCpj¼D´>DàBžBÇÉBÀAûFäB,ÙôB$BëBKû*BU‰PBT_SÞBLD AÍœOBJ[ªBŠK@BéÕ]Cm•BêûBîÆCB¯LNB4ø®B,½õB‘ B;XhBpB‹m(Bv€™B‹qB€%©BgÐB#bÅB%jöBˆ­Bï½B<ÞB B=sÔB=$üB(ÔÿB™™CçXC}2ClÖC6>CrßBwE·B B#hŠBFBC«,B~ÑqBœè$B¥ùJB©ÎB”ÝBƒÍ¸B9¯hB1“tB eBšeB&saB’A:C£ C “hCQC  aB÷9=Bb1“Bõ½B&fáBƒAï¡çB åBdB‰£B› B…ÐBœ³BBm¤VBYh‹B(íÿB6BwùAÞ6LB)qºB&JÿBEqB8•­BLOªB5]¤BQe–B!B·B#7€B”µBÉ›ÝB¶sŒB¾PB¿jAB§³C0C=""C0;BC.v"C+.¶C¡BN: BÄoAÞÒBs+B סB»ãB#’ØB=wB,…9BWéC TšC¿+,B!ÎìB-½¹BTÓB 4æB ÏB*ŽWB\‘2BP5¾BNRBŽdJBjñôBmAý| B! ÅB›? B»¾ÕBý{(BñÇBÒ\>B•”0BˆíB£íABÍÃRBÓaMBÄP”BáÔTBê·RBÐãÍBµÖWB¤B‡ÐBYwBC ¶Aú¬ÑA¹ý>BF¢Aôc4B5UB!ÙBõ³B‡ª„B?ˆ“BcFB2Í2B9x Bzí•BaÄŠBDeB:Á;B'¾µB¨B1}`B,ƒ-B waB MVB«øB)UˆB#}°AïùÒAèæOBýAôùÇBÝ,BP~AÕ A÷Þ€BsBAG³BŠ;ÄBÀMÒB¬pÓB˜ŸvB™èBûjBB9×B­BB6 ¨BaÃÜB€ã„Bn5mBs”lBt2B7 YBhËB+vîB›AãéµBŽÔBWûBÕûB4T(Bù|B:šâB4í Bú’BODKBØBöFâBðzÀBé¶BÿîýBµÌ1BBzCB{B ŒµB*eÛB©B]B•Ç”B‰¯B~mWBdð[B”]B+B\†B›üB$êùB)L B3D BCô&BI BšwC6„C(ÉCÞzC¸ Bí[·B\Á,B kB$65Aü—B+ÑBxæëB±_B˜©B¤¹ˆB˜%ÔBkæB,(ÑBÀ]B‡+B>GDB†#Br¥C ÅC Ú CLC&“BâÖsB`0BѬB$cfBä,B ÂBËB5\”BbëB°ƒPB–ÖAB•m2B3´ŠBS…·B ˆB,\½BéA÷EwBö6Bá|BD-×B=QBS,JB8»B% ¡BFñBóaB.uGBqóBÍ’·BºipBÁz’B½*>Bª£óCÊ[C70C'ýbC*ùÎC-X Bò¥ŽB=NB b°B;1B&µAí.ÈB@]áB5>ÅB1ÚB BB ¢aB>öDBÁ©4BþB%”4Aô±ÚAýB:лB4mBj‚PBXçBUÊ{BhæÇBGBLB#&AÛW|B̆B‹*GB©0PBÛ¢´Bê÷²BË,ÆB‘ÖrBjâxB­¿ŸBÔ}ÝBµ#ìB×ÀzB߃BÞTœB¶ B¤ÌÃB­Z-B“h_Bl`3B#ÕAüAÍ\¦B ¾AÈ“B£òB‡BB†zÓBa+óB  šB€BBêBK2xBiøÓB/ýŒB/T­B.–B¨BB<¥¼B5L.B¶NBBS\B@„Að¨aB}0AõÅBOÅBûlBïB ¢²B šxAù=›BwBþ+BŒúB±BB¦BIB¥GcB{3pB%IDB7Ú#B4ÖBk£ÌB]ŒB‹áöByÜBk$B,l/B3ÚB!eB<{B>äB(£êBߟB1ÄsB'OBy„B+ê`Bƒ‹Bz¿BO B‚å÷Bþ»ÏCìöBÙŸBñYÛBÌxˆBD]B-LBŒwBÙB~š—B§±-B˜µ B™øB„¿†BftàB¼”B B·³B˜EB¸ŸB! B¬vB"(NBB ÉBª §C(kùCwãC·YCÅBånçBT «BÏÅB&”B8Ô#B’ÄðB²“´B¼ˆABƵB¬OÝB²‹ˆCÈpC9q¨C%Ã5C-Z;C%6Bä÷1B;Û"B -ÜB ð[B(’œB èåBÙB %4B"qbBÜ3BxB$&BG‘4B÷A÷dZAÅEžAùÀ3B#ÿuB%¶áBt2-BbVBSÀmBk}UBSz(B%tóB5nAóŠ¥B NB#áBŒáB\ç%BlØÜB~=¼BXF‡B\Ú¤AûZ£BõByœB¡Â'B¸&YB°¨BÒîB½µlB¶£ÐC.uC7#"C“æC)ÐÏC ¿¨BáíÿBC÷B”B¾XBš%BòˆB %žB„ B!{¤BGŠãB©°B²“B m¼BDˆAÔTHAñK¥Aõ BB0 B ÆíBd­BUúBLÊ'BSˆBdrB+},B*ÖÔBelBvØxB¥Û«Bæ*œBÙÞBæƒBÉèùB–hßB¡ÓBÆáùBÎÈBÓ%dBìi¥Bà“]BÕ1mBª—B²?ÆB‰UÃB=«B& B¤B°AüýÞAó ¸AüŒhBÎBopB‡ FB]æ“BE{BEšBVC#Bb¦?BYÎÐBMsbB3 ‚BI<ëBUùBwÕB&Í$B ×éBDûB-BÔÃB4^}BxBÆ€BµÕAÓŠB²ŒB$ùßB~£BÁ¿B›¼B6œCB‰¾0B™:ÊB£¦úB°LB¶> B‰n…BçB.öBGi´Bvc¢Bˆd¨Bq]B‰ÀBsçB*ÃBûöBŸµB ÙB"Q“B!B;B.MÖBã¨BWçÓB#6kB+í/B2åËB,ctB6y-B&‹MB6ÀTB_I:Bf>ôB_õXBV B œ B'L’B{ÆB›‡®B»“B© @BÎ/oBÆ9vBŸt÷CÉgC-xBC.QSC74C'ñ[Bø)BGò>Bo¡B½úB,ò¸BÜB/æ}BÛ„B’qB«ìAâB˜B©€B øªB \oAÓþ¯BàªB «B1B%uB=oÝBG¨4B5jBV[¨BX±»B')ôB4c†Bc!B}+B¾˜•BôuBÈõBâÅBµ%ÖB€8ÕBgøBÒ¹ïBÏhåBÐtBò$8BÚ:BÇZâB£ÊB˜Ù BV„BjÁÁB2zAúmAúcB=FB#È“B›xBR©BtnhB™’ÂBwWíB2àB"ƒÖBKdBLUBD¦ÚB.¶BAï9BC–[B «ÁB¸xB#ÄNBÚ B"¥kB14B%4ÀB#ËB¥B \|Bâ-AæM’B èB´ÿBù‡B)Aè%¤BB•7BŽGÒBžrB‡[mB¢BGtÎB**ÀBæB)+ñB,¯ðBª›BþÊïBíÛ_BöIŠCÝBµiäB-VIBÈžB×êB ´;B”5nB¡:BžyOBžo±BšöEBSÑ9Bb`BsxBc’B2iRB*gBjB#äüAùƒBB¤B®¥¯C;C#Ì­C¥§CdéBó ByéBÇBÓˆB|öB/kðB†IúB™eBœuíB™{mBŸ´6BjæBã¯BæAþõÉBÕ°AóÂ|BŠ’œBõЬC3ŸC ~SC~üCSBtDäA댑BŒ“B*1{B"šB')…B%jhBj»BŠ 0B¢Š¦B“yîBŒ·*BBõÙBV¤B$0òB#ËB6ýoB0õ5BJ@0BQW’B;“xBT#êBZÎ¥BN‹:B i;Bê8B g¸B¥ª+BªÉ9B¦ÛuB²‹B½Š,BBÛC ^[C?]¡C7¹ÝC:¥³CõxBÓ2BO8NB(&hBNœB³AívóBÃBVÖBDÑB*TBÝ&B àmB ¥AB9PAó¥¤B,KñB‰B7ï¾B §.B+ð˜BJ§BcK¶BWj`B÷BF~BWVB ªB™€©ºC8­C.6ìC#…«Bá÷ìBH«øB¹NBIúAíªBÛxAׯ6BNB7¾TB(x¸BÌ)AËœÕB3JèB Aù¾lB*iB7¨B  Bã×B9‘¢Br¡JBiºrBGÚBg·B#tB)NB%¡ÍB“ú—BóbBÔñÌBË CBÇúBµ¹ýBoÀB§évBÓ ÐBݼÀBÜ’­C^§BÏŽxBÈdÒBÆg6B¼'¨Bu•BV B4^Bß¿B®5Aâˆ!AËLAç By!Bh ·B‡‹~Bm˜ B86 B!ºB1ÍSB=PàBQ0BaÙB3” BQ ©B7ýqB$²õB:ޱB7SB3ç™B#³B%ÜBUAýÒÌB (:B%dB3‹}B/¯7BàB$âîBŸzBµB5 4BŒYB¦ë^B¦„+B±™ùB½xèB‚Á²B/)B(BEðoB@pBZJÿB€:Bu‰úB‚ô-B0ÕB»yB"•BTÛ§B)j‡B.ôËB2/·BFÐxB?F«B*´VBK!FB#f&B—ÆB->VB¤v…C?YCÈBåçØBóäBÉJÜB-¼KAô ¼Aü1B-¼KB€ÄBƒwèBtæBŒí‰B–jBv›BW•BŠB"DºB;™SAõäB°ªB]§BHõ‚B5€B—9C+`C CÐoC;sBâý±B>â«B¥$IB[M¦B'`jB9BJBTVBˆ£vB¹•¸BŸ_BÆl?Bš».Bªæ˜C ±CHSeC0à C3AæC"ìkBõŸcB)!tB VQAæ›\BælB ê)A÷PFB ?yB'jB!võAó¾ÐAÙ,èB T B[ÈB ãBÏ]A÷®€B ÜïB“BhóB~r¾BUMBQYBVø B6"JBKB!í:BsuB®\+BÓ®ôBÓåÂBán,BºSŸB:™ŽB…3¨Bºµ7BÑŽ>BÒ’ÑBõBÆãzBÈYBÁN(B§@B|`ïBIÝ=B—Aû*ÏB 4B ¦[B°ªBïÜA÷ BoW¬B„ÑBy‡BC=aB!)BDÏgBCðÍB=©©BHâ^B7>Bm×áB3 nB`‰BWÐB"ÐÙB;IYB$ÎBÉBF8BJè~B¹B.‘ÍB‡ÔB.ùnB WñB0OB"»¾B âVB2pBדB³.B¯œÆBªâ=BžÃ\Bx«ØBwÎB •}BD^tBw0ÿBï’B£œBNUiBƒ@B$ùB'¥—BÊB?$õB ëzB% HBEn’B-ªîB+¡ÇBÔ˜B1F÷B#¯+BéB9žB²KÔBúãëBÿ¸îBî¬BÜöeBÂc B$€ÈB¯BÔB.­•B‚ÏœBŒNÚB¥ñVB›Ý‰BíÁBp@B€ºB¿6BkÁB/0ZB–JBûB$tHBDf%B#{>B  C"€yC ¸CzC,­FB÷+„BXgJBÁýB/æBìTB'îªB† ~Bž ¿B“|BÕüBÎÆBƒ$´BÄ-B.=Añ¯ÇB3¼ÅB,ZdB–)qBô;˜CýC¥YBù$ÍBñ¥”Br6öAØ|B+÷ZAò–‹BJBkBAÚ:Bš ÀB—ÝûBjB‘$ZBƒ£&BµB"ÿ5B&JyB<¬BxiBÀBeÏBIZiBBÀBƒÌúBTºçB6.»B-~³Bš~B4ã÷B‰ÐàBµ(…B¢7B­ñãB­kFB…EjCïC@êEC1§ÊCAD,C5û{C‰NB]”IB (WBµüB2|BèAå†SAó«wB¡¦BŠABVLB I~Aé >B6UAûbB2œB=âAý9žBvBC>ôBWïBOKB\ðÓBGüjB7¬vB ×IBB‘%ËBÇ3BBßH%BîJBâÜ}BªÏøBPB­Bˆ0‡B¸yBÕIBßÀVBó æBǾ3B¾¨?B²B«S³B#ŸBEDBBBoâB0LAå¡?B‘ŽB@Añ dBv%ÃB`BjkBAÁB=oÀBFø°BÆõB8=çBiQpB]/“BJÜBÕoBäSB(‘SBC0‘B)¤²BLB$»ÄBxRBMj Bm¹B¢7BÔ×AôSÎBÎB—B \ BøUBE^ýBt»B¤5Bš)ŽB“WBžQ®B/,B"ÝB/­ßB#uÿBjdšBnì7BhîB0}B„'#B>ðB<öAöwãB*×B'°¯AæÄ«B´1B ÙŒB&÷B$ç:B¤ŠB4¹7B³öBM^ÑB¤ˆBÿÔ˜Bõ»Bðl`Bð&/BÌþ5B8{Aûx§B ©B1Bz5¢B›·ÐBå¡Bš‚®B¸«B]SkB ˆ B)B:çB(è9B3í_B#Ž BêîB!YB6SÊB§¬C XpCa¾C—`CüÁC 4Bf¥óB(ÃB¥nB*%B,”›B—T¾B¥ÜrB“äïBmÔiBŒ¢ÄB–1àB(¡B(qôB’\B#‚~BîOB|xzCžXCÆ,CòëBý{(BñG›Bj[òB·ÜBA3B)BBΕB¡^Bz1Bg œBŒ'B:ÝBêÆB+ ÄB8(UAß1JAîáµB4#B ‚‹B'èB7ùQBÊöB?BnB‚ÑB+½B²Aì:dBüÝB™š¤BžžpB |BœNwB°§B€BôB(õB*—SB^·B["8Bt†3BI lB€ÕOBV¿$Aõ|£BIÌB–}B%ø£Añ'Bã)BB‰°B9 eB!UB,xB64BU ~B¡opCõBþMæBëüøBõ}-BÃÊ!B/˜AÔFB ‰KB)ØñBVQ‡Bâ¥B‰ÚëBW}B ÿlBY+UB~WB#ûüBR¥B9~³BMßÿBOºB`%Aî9B2AÒB«ê C"šãC)?CKyCœ¢C´B}ZB%ÔB IâB~&BhˆB‡ÁkB‘¶îB¡:BŽÔyB—f²Bˆ!B ÜóB ŸíB5 AßdâB61ƒBV'C$QC¹CŠzC@ÎC€ÝB‚ºâBÜ8Aé,¹B$òB žEBhþBH`NBv~ B€¸ñB’ˆB†<õBRh’BK&B&å,AÛ†€B19Aú¢Bì B1ôæBMÄB4¤eB^@KB#¿hBE;BßžB "B1hƒBŽI B™9†B›56B¹Ó-B¨K4Bµ¤üC ]C3+€C&ç C2æƒC;ûýBø\DBB‘ÆBÞŸBdtB+›çAùÞB˜×B#m­B ü­B²VB ?AB bBÇtB€BzdBâàB™DBOB Œ.B_\èBvîBIµ§BAŸwBO¸BK¸Aüi¶B&u£B—¼ÁB±9BBá4fBÑUmBËÆÖB¤+ìB‰ZB¤eœB½LBÎÆŸB¿˜BûÐfBý˜¦B±CZB¥æ:B–=•BwHîBG<B'«@B )±B2HBxœB;äBB"XÁBhÅ Bƒ3aBl˜®BCHBHØBK9B;P_B/øöBylB6‚OB Br7B$c/BxlB6¶A·Š6B s¶BB£BGTBDøùB%ØmBimB%åB 3pB}B™-BfRAò+BÀB›mýBœ tB”—ÑB¥¼BŸ™¤BIT\B B%ÐB:ŠËBvj¤Br?VBxC·BuÛ_BD}çB<¢^BÌBKs¡B*.XBºÝA܇×B B%³;BÑ©B¯B ÆzB!À§BY¼B"úB˜åÈBêŽBùDßBò}ÈC ö7B³Ñ—B©4B.„BB)¿ÄB&óB…³ÚBšó¾B•à:B°zB>ïÊAöhÓAþ+[B QæB:·BE¾B*ôkB$RXB£ÓBHíB«™C%2ŒC&9IC Ò[C„+C…UBƒG©B˜·B¹–B ðB­úB_BÅBˆÐ÷B¤£Bž_8B™ïBŠéB)Ä“BÔBåAÈüB8^B‚'®BáàmC „FBòCC[}Býo²B€!åB-+B KB gBVÞBwBW˜FBx¬…B‚ÔÂBŠêwB‡hÞB{ JB1ô¹B Bô†B\¬A÷œƒB YÒB2ÝiBJ­B©xBU(=B;z7BB%çAü)åB /„B!OB•ï!B“œB°kfBµ9BŸ B§GüBû7C5D·C5Ý\C9ä!C.‡Cˆ BLðB ´¬BÎ B§¾BI£BzÚB)ÈBZBÞiAþ8ÑBîFBºŒB5ñAêê†B ?!Aþí–B1™BBN”–BP©GBgB#¸€B<¨#BA—Aóq5B¦mB§=hBÀWZBíÉðBÙ°GBºêåB¤áB„?½B±9¦BÁiÞB°£+B»oBøŸBî[œB°!×B¥$dB¤|™B}’]B;çÕB ãB(*Bé…B9ÔB \BôBŒB\½"B•Š-BZH«B/¤“BåýBFò«B~sB2ǪB;Ë;BŸAòÆ BqnB+U)B#bBe BnB-B ÚlB3"ÑB99BûPB'ðÓB fB`6BAPBÿ³B páAÙlB1àBŠ–BûABÚGB™ÝBŸhBBˆZÕB„oB'vBTÌ3BMÉùBq˜LBx…^Bj °BQèÇB00B#”B°=BG¼ðB-­ÍBÄJBëÒBB²BïÆBRB ŽB1ÕCB"žB4X‡B˜“9Bè}ÓBë/ºBòÑ‘BîîaBºjBQ¯B48BfåB2XB‹OBcBŸ3B‹~­B”œSBVƒŸBýB#B€B$0öB ¼Bc B1¥B*0B,BWB7 B£7AC#€=C- €C¥CšàC{B]ù;AìâèB'®:AüùAí÷ÔB^ô2B FÚB¦]B‘EÿB˜B‰¹OBMfBCKqBN B ŽúBÑBˆ¼èC»ŒC̉C~»C`¢BîááBÉñB+#ÎB#ÒBè]BŽBDzB*CÄB…iB†À¼B{BnüBnA~B_DBd¾B½B™·BLKB+iB@ ÞBZ`B__ãBT›)BlM~BGïæAß!ÂB;—B&ebBŸIøB¥Œ^BÄ'íB¹ÌB¼hGB¡£iC ÊKCB€ÁC?6CBÅwBÿœBì—BÐvfB¬¢B‡¿B»e$B»Õ¥Bµ$/BÛv½BçH±Bß-7B´FB¡­‚B±]\Bpn9BeDBŒ B ]Aö "BCAÿi3AÏÒ‹B²òBgOˆBk÷B4^+B‹B(b°B7EÅBþoBCKB#Æ„B?Ë¥B#‘¾B•ÁB™ŒAóþ4B‚B"ZÞBÞ6B@ÒB'rÐB#ÇyAúœ©BÊBÌqBc.B_¾B ]0Aò‹×B ÔXB ^BŽîpB“aZBœ jB–B®‘AB‰¨=B ›B'–B]uúBnOmBTGûBm‡mBqYNB_(–B:óaBê,B_ûBkBJ•KB'Š*B{,Bj%B%¦ƒBšLB!²úBWB#ÐRB.÷Bš$lBñ¤ØBö’`Bà×äBÝ/BÌ@FB@k`BZÉB B .„B‚ú&B˜Ë¶B‹TB‚²ƒBp‚ãBp²öB(C½B,&îB(ƒ4AùÀ'BkIBGÖiB,D½BúBBŠL©Cî$C³C {…C¹ACZÏBDŸVBI"B!›åBtgAÕpBW†¿B¡Z’B¶qB›hðB’VYBˆ;ÑB>ÊB?_Bv]BrB3«íB“m­C5ÆC ñÜC ´Cr‡BæÊBP”ÞB%‰ªB6TAê1xB$\B'Ó=BGÔ}B‰—jB޽2B:.BÕòB.¥BfNdB=®kBÄ_By£A÷^‰B(k*B9×»BN†B‚ÚåB\!Bc[B11OB•àBŒÞBBÆCB™¥Bµ'BÑ…ÊBµmûBÉÛKB©0VCÊ™C9ÀC;‹ÞC0Ö‡C(›BîÈ¢B4çOAñuAî‰B()ÇAÛÇB‹B.hB961BéèB ˆAuJB:ºB ðB&7B5UB%·ÑB¦™B/>FBrÉ“Bx{DBZ~\BaøÇB?RœBá—B-(ŸB"5¾B~¶tB½òCB÷®„Bé¿7BÅïsBŸ^fBa¶oB¡“ÈB¸!SBÕ—"BàóLBí#Bè‘KB­~AB·0B¯ÈOB’#cBJg$BpAAö‹AìQ²Aà¼RAí’ÚAÒUB$*B]Ò\Bj®]BaO¥B ·B;*ïB&í³BI(´BˆrB0€;BDãÙBL¸7B ùnB±VB ÀDB±ãB"õšB)6üB¶\BGjBLÑB(•ËB¡©BÍðB ó¬BB»úB°±BÔ BÑB´!B ,°B¤ˆoBš¨B¹Î•Bw;äB,XÊB‡1BLù§BbŒ·BaíB`öóBqóùBAÈFBTUNBè©B_œB FBSìB<Á½B1¯"Aô¹B&¸B0Á¢B/ ,AÃ_B B3GÉB¥ÐSBïYÂC ‡BÝg‰BèÚÇBÈâ0B#BB.ñB$ÎüAþ0iB¿-B•iÇBƒ9ŠB…ð?BÃBJÙmB*FBêˆB7sBé)B'KB)¹£BAB ˜2B}BÛªC#‘¡C¡\CöPC0ÞBòƒ_Bec£BRººB:« B=ñ–B0³6B]ÏBB‰¦ºB¥ªXBäRBœÀžBh>gB*ÚB"%B1K"B#VB?ð)B”ŸÚBú$»CO¼C°:CmÍBòBLä€BbâBÈB6ŒB)3üBm[BasB]9BwGB”BüÖB{׳B,Á™B/‘B ê)B\1AÌQ"A÷ÀVBÓ¹BU;BNkBLEØB@;)B"ȸB'ähB3ôÜBHµYBŽ—BµÜBºr Bµ8BÅsÒB›Ã¼CoœC,°¸C2‡èC<ë„C6Ì7BéØ%B4ÔæBaŒB§cB)a-B $PB ÑmB§BÿëBž’B*aèB©¯Aë>kAâü÷Bõ BžB ”YBÉB"ÃéBsÊ+BDH©BVaWB7ƾBMîØB2§5Bb°BTMB€(rBÖ£TBÒŽŸBÖËaáBô¶BO÷`B©/BöòB LB9÷Bd BG®B‰0BsíBc‘B+7µAòmAåMóBºÐAîSBq¦B m»B:?ÆBywBh¾¡B\Û_B$ÃÊB1êB ÛB‚ÂBXtB•EhBÖбBào«BÕµ BЗéB²22B€–;B§ÈÒB¹K€BÆ5¾BÍüšBä)ƒBàÕ—B­zB¥«Bž»…B‘êGByÄOB1eoBßlAØkâAÿ¢QAîþ·BEÆAÌ‚BXçáBu<¥BoˆNB#ÎÏBè´B;´BYå.B@ߤBK#­BLkÒB-‡¸B&LBåBquB[©B-tˆB"»pAóiÄB©wB:7–B#©cAóõÙB¾ºAü³_B(¾uB'˜ÚBb`BÑõBG\ƒBsóB¸‡B˜ÔRBªÃ#B¢BBl<B&B/hkBuVLB…—KBLI«BOT„BÅjB‚Ž_B"ŒB+BâBè)BjÒB+%B.cØB"ò B˜zAä(ëBBB=}B2Ù0B&K¼B8„%B•šSC ÛrCSXCßøBê‡"B¶¤õBJÞ6B†ƒB4£×B.KÎBˆ†B“YâBˆñòBªÍÜB(¡ÏBUß‚B}ì^Bg÷;BGvBFÚTB*ÐvB_ÕB*{ÙB BÙÆBØÔÛBÓVœBÔÍœB¢œB~þgB±r«BºéCBʇTBÝp©BܽÑBЉB·úÈBžÓ`BšSðB‡ÿ(Bl<B B"‚AõìüBkßAÿ­"BmyAúUÔBk ÿB`¼qBV¹§BE•êBà]BHÐþBs­²B8µBy*cBQMEB4Û¸B/%uB)ìäBžBÃ3B"jB"^B BÎNBAoÂBÅEAïñ¬B?ïBöâBOv*B#äAÿnFAÄ?öBH B›_ÞB˜ýBµÜ¼B¤ð±BŠ€ìBagLBèÙB'Ú¤B^U¹BgBo)hBsáB‰#gBqü{B ZBŠB8ùSByëB+8.BKq2BBáB$êB6L¶B%ìjBA3B"/¯BD2eB*ŒB­îœC±‚Bþ¶CúœBûT€B¬(ÄBQYB6Bt”B%/ôBwBšóB”mÇBªzB…ºÏB³AûõBŸÆB,6üB`'B'”tB4%ÀB)D.BÿB ¼B¶93C€öC©C| CHBíÏïBe'ßB7AçB.̆B dB[½B_þ¹Bœr©B¤EBœxB›¡ B†ùB(‚éAþ¶¹Aå`4B ŸB-ª$B˜>³CeC OCP¤C›GBðáýB}2ªAâ”ÒB0ÓÀB >ÛAösXB¤§BWºaB„rBŠ%“Bx¯ÜB&BŽÀæB<+BGÙB3ZÞB#¿¯B#VB«yB/ìüB^fB1Ü-B-³ÁB‚B^´êB;`µB B4¾¢B®0ôB´¬‘BÄ‚âBº….B (hB/ ÎB‡BÞ¬BoB–ÓB/f B)Ò(B :eB¡úÖC@C›ÍCb”Cx”BðÓfBbwB1©ØB0Ä Aý€rAägvBeeB¡ó B§z†BŽhÀBƒG=BtíþB+=B!½B)ŒíB'†¨BöIB•øSCIßCŽÚCØ©CbtBãdB[óÇB¨˜B hB,vBËBÆðBO—\B‚i›B›ÐyB*-BúÕB\µ B,M»BÛoB.µB¾„BârB©eB8,/B@‹sB:<B¼˜Bf` B6£áB,*'Bt¬BuùB°p¿BµºB®xmB½sýBº’B§›7Bð•ÜC$SC0ˆ»C:$C,¶!BÊk±BÕB0ƒB~iB j†B%ÍPAûÁBÿBB¤B-ÿbBgB"ÏîB!ûnB Ö¶B¥úBŇB ^BÂJB7·×B:VBvNàBYí‚BB0šBKŠÓBêBÉBæ™Bœ'BËCBàªßBÇ2²BØ÷>B˜2„B˜ !B›–MBÆéžB¾2`Bä0ËCä*BårBÝR B¢®Bšl:B—bWBE×7B'} BÊBpAî!×B ÞB ùËBSBtÌ\BH}JB[͈BÓ‘B$¾§BYQeBZ!šBY€hBb(ÓB"'¦B*éøB#Œ”B!ÑKB¹ŸB- ëBôGB wB\°BÐíB ÓËBˆ B?•B ïAòƘAô B%Aë%B$ OB#%êB‰×ÀB¨Bœa*Bœ§fB¡Î¡BZ‡fBhJB,:ŒB^+!B.sÇBSrB‡MBt±uBV—¶B%ë*BàMBDMB(.Aû^bB²óB&`yBŸjB'º B.dB,™½B(]B`"B-TGB¦¡=BïhìBùÙƒC àBûÈB¶ÖDB;¸âA÷/C LC!(ïCôHCöÒCø•BeXŸA÷]cBdB)åB)#4BoB|kB žMB”AãBŽ+BzTºB(GøAûd'B&yyBNjB/°B”<Cª´BþþÑBûžeC(M‰Bï‰"BS ûAËÏjB.áB)€xAòþ)B @B5cBrŸBŒŸB‹p®B{¤MBoàÅBzJBÔ¿B5vB1Ø AèƒyB „LB.wŸB?RÿB-fŒB79íB7ÌBKèBI|BAB(½B¢jeB¡Õ×B¯Ï„A첟B°0B) BÓBNEèBjîB`†ùB7TØB@qˆBôõB —ÃB g¢BŸÛ—BÃBÖ‚çBÌ£BäáBB¡K`B~‰¥B þtBÕ¦:B­ì‹BÀ¦HBâcÂB³¹(B²õ{BªšB*¦B”Å"B%ÞªB7.BÎB¸B4¢BŒ}Bã¦BprB…/TBFá(BfuÍBB.¬ÈBJåºBSˆcB_/pBOè‘B8q6B7˜]B —B!#BweB-æ+B~ BB–‹B%$ÎBlKAɇ\B-`Bô±BžëBŒBº¨B &ÁB >¾B¥ÜB=©ÇB”^7B³÷¨B•ÊþB«ÞÒB•ÕùBdìsB0Ù·B3mTBfoóBL–©B€n-B€”¤Bv;5B_BtB°B‰1BJB*ÕB0Å…BJºBrfBÄOB6ž¢B4Ú¶B"^B)¹®BεB)‰šB¨ ¦BùòEC ¶B÷øBçTkBºŸ¼B!ÖtB#õ¹BTØB)­.BnèB}bïB’±¥B”jƒB“¥àBac¥B—°B¢ B$€B»ÚB%§`BÃ'BâBë—BM,¨B±OœCûCÏ™C.sCÐzCäÄBS©;B £QB\©B-fBXBwÛB“B–›BÃìB¯r¯Bir$BSØAÀ…þB×FBŸB*ÂB•­C]0BïÛ–Bî¡¥C¶ÒBûïâBGrPAãøøB ‘½B øAÇýB±oBõBxпB„Å·B¢¸ B…»BqùÉB+úšB¸ŠB ›B&ÃAò%ÏB2§B3S^Bk»·B\‚œBO1÷B„uB?DAöyB"‚’BDeB¦a‰B“¼ôB²mªB´m®B¬Ý¡B˜{`C°C:¿ CE6\C$ŸÕC1aíC é*BAeHBf4B»ãAï ”BoÿB”²BëŽBB'y¸B8SB FtB Aê33BöfBâ´Bœ¨BØB1üBK3ÚBo„ñBe2¥BTèvBB½‚B1öTAúeXB/ŒBÊüB¶½ýBÓ²óBÑá‘BÔ ‘B²ÌÛBq˜Bwù\BžØB°ƒB°ƒHBÙðBÈí¿B®Ð/BÂ5ŽB¸“8B’ÿˆBH‹BñwB8ºB ]B±FAåÎ3AøºBÂãBpszBQe(BzB †4B3WB'/gBA B`ÞâB/)2BMgNBD÷B Ü%B&FB®–B+÷¶B¼ZB.ÈIAþ®-B éeAúy¡BÆ[B"&BÛB ;\BÚAédIBÊAÊõ>B4ÒB‡%vB«Î6B¯+¸B²l†BŸ°bBy†BB£2Bc%BZøBT“~B}I”B†KìBi2SBR ’BFémB!®®B¢mB ¶šB&B.¤ðB%BHáDBì¥BáVB*ÖçBF»B;B5/ïB¤©uCžxBü–‰CªBóëOB·•B 'UB& üB*N]B)K¶B‘,‡BŠÃ«B†ª'B”ˆ BŽO[BF YB ûlAîâ}B _Bø©B ±ËB ËOBFAøÎÞBE¿YBÆë¡C!ð|C 7ìC‘´C®CrƒBL ìB(­AéëWB8[yBÅkBt­½B¤ü¡B§æÈBÇ›—B«ÂÂBj‹„BQyCB'<ÊAýcñBB}B(8¶Bª@´Ct C6ªBþ…¹C„CêlB]0KB9BÊôBÚÄAïñ¤B+v…B!iBu¼åBŽ8HB™°TB˜ÅA÷ BØ÷BwcB Õ¨B%QrAöÞ·B2MB@mÐB"ôBºœBôAæiDAì¸AÿÑB˦B~ÃB ߊBAïdBxu BS1¦BCS(BN%WB*+ÀAòéAB/‘zB¡c{BİõBÍO®BÑ)½BïO‚BÀBXB…YB€@BÄDB¹§÷BÅt&BôyžBÜçB¿u‰B¹ÙB¹ûBŒÁÃBCÛ²B£õBð‹B$§AB‰BB Û¨Aù-BVåƒBc`Bo-B>³B&|ÃB=¯ÿBG,vByIBCñBHë•BWôB.ðiBŸÎB¸_Bö(B:¥B ؼB vÛAúöB1fB~gB^TAûpÔAõX³Bý=B|MAú"íAº¡]Bµ#BˆQB¡àpBÃä3B«¸¶B¶ûàB޲qB+¶B%¤:B@6"BgãÌBb˜B„gZBs^Bj”BBL¤ÑB@àSBRÑBe1B"ìB8AšB¾>B$ÖuB( °B«ÔB(§aB7]·B&kDB&†0B³_\CfÆC¨–CXÇC9BºpB"rìB ŸBAÙ]B • Bx|ÔB‘œB˜o´B˜¯*B™äLBcÄB Ý5Aþ÷BA•B aB6¿B17®BÐYB  B-¥CBÄjTC0C/žC å3C —Bî†BZÕ€B6JAæ¸JAé”ûBš=BŠðçB«ÊBªs;B®>bB¬ªBˆF²BIEB«½A¦JB,)tBÒ B©^C"‘CWºC$¤C§2BÿðÀB\¢B!ü§AúS‚BR–B"qB3Q.B6å†B{I,B™lB†ÁFB`ºB„|BEÒ«Aø›B=…Aý„ÐB'ƒBàäBV’(B_ÓaBðB@2IB`«ºB"5bAÍ :B!BQB‚5ÐBµ:×BÄ^ÊB¿9B³(B¢‰FCÂC3ùÎC&°^C,¦‘C&ÚëBÞ†B`yºAøk AýPäAù@‚AÕ?9BYPB0„ÖBŒyB»BµBÅB#]AÐ2ëAöaåAìf"B8BjúB¯¶B2î$Bne.B[ B ¯B>àÉB*XAìü!B/˜B¢^B̰BÀXBÁf7BÚQ B°þµB“?BŸ™ZB§•”B´—B¨Ž"Bþ^BÚQ†B«.?B¤B#BT–B‘âÈB6­B  “BçBq(BVEB dBPAã èBC£úB¸’Bjô B4BdBq«sBZ|Br gB9QBY¨ùBX{±B+­ùB,ÉBB¶ B”±B)BÕMAÞí®B4Ý­B#íB–AìÂ0AóÝaB ¡üB~þAÞ—SB ¹¿BFï^B’»B–‚ôB«S_B­ºB½úÞB„á™B0sËB$CB:W„BXA0B|ÚeB‘›HBgkßB\¹B0=òBEFŒBYÎMB7€˜B8¥ÝBÒ÷Bk'B2‡…B"Aø` B÷ÅBeÏBB+Æ­B»žBù«™BüéãBþÙBôkÚBÉìB2øûB%stB<—BGR–B]²tB‹IB¨yBœt2B‚ûŠB|NAÿC~BÄ&B!ö0B?¸oB„°B0#B#ŠýBa×B*ÃB¼¸EC$ OC,çÇC΢Cí©BäÛºBBÛQAú5CAóJAúÞB&ùÖBœB©ÑÒB©œuBžaòB‡¶Bt¨RBÔžBÁ Añ¨ÏB™WB #äB®ïC]“C ³QC B[CRöBôçhBˆÅDB GAÛ»\AÕs¬B$BB‚vBxD\BƒèB‰+¬B…FBLªB‚Ý»B>©HBMB 1ÚAùÓ/B ·½B cMB\þ¥BF©[BVköBmRrBN,mB(¦®B B1dBO­ B˜;nB·¸B¬>BÁ'B¿ílB¢ÀCO[CBl©C%R­C+=C)D‡BàùBZbaB ^ AþÒAã‰oAÂêBìB%KB%°þBwBB"étBÖB¤«Aò9 AǺ8AøöAÜœ\BÔ§BBI*B<‰ BXΈBULuBJÐÐB/®­BÇ(Bj1B‡ºìBÅk«BÙsŠBÇzBØ(KB¥¬ÄB†{B¥ÅÅB¸~ŒB®PMB»ëòBðFÌBϯBÀÁìBš-‚B”ÎýB‹=zBBýïB"¾/B*B Q•BcŸAÿ}B¸ªBú BtI+Bh”°BW³(B$üSBåËBqõTBPFiBM‘©B26\B6P B*¼B.8B×þB.Í9B}ÂB)½êBºBAû†‘BÌBWaB%‡AÎ!?B°TAúðAýÍïB¬B£ºB'_„BŒ×óBœ~ÆB 9BZ9B£ BzM³B/¬B5ËHBC?BYK¸B•3B’çB]ÛBnú«B9¤B¾•B.z6B2ÀpB:Œ–AõYiB ç B@K¼BÝÃB"[UB žB‚øB$È|B0FÉB¬êBè&›C1CXrCiB¹ëŠB2=«B* B4^ÜBK BФ°BÑBuB—úŸBX¸›B‡l§B5ˆBiBÜdB,¸6AãÜB‚tB(S6B#ü¤B$ZßB®LŒCôÉC(pC‚oC—VBíLdB7:—BÚtB-Ê@BXB$¥ßBƒZXB¥"âB±ç B˜Ù²B‘õÂB›;B!È8B'â·B'˜­B,]ÓA¿Ä#Bˆý!CŽ)C jBýúC=Bë³Bmw+BÆB °íB HžB0vÝAýâB`UB€Ù{B„L§B‰ÉðBeBv™ B/’úB!„éAëH~AêsAÙ3¨B8ŽùBû¤BXF/B`Ù^B`ßB@ÆÐB6¥B,ûB'ÖB0Ö B’ä³B¡ÅÓBú2BÏUB½ÅB•>$CœjC:7ýC.cdC!ã(C&6^BÑ 2Bfã…BPBÛ AÆìÓB -;Açu¦B##UB!õiB ˜_BBe2BÜBÉmAµßsB"£sB¯nB ®ÅB÷ÂBXfßB0ù¢BQsBWêBR&B/TzB5§B ”B’4BBˬ¸BÐb}BÂJSBí¸‘B¶££B€â#B MbB³æ3BÁuWB±²BCBÐÌBÁ?úB¡ybB“ÌBˆ‡WBC÷B&iB³0Aû]ÊBÔ÷B›îAÝþ”BB¹Bˆ¨B„[lBZìÈBPBB.Ž^Bg BM¹xB(¼GBN'ÏB-¢TB6BB?¦—B£šB+öB+ HB1c½B%R0B»—B¡-BùB(ø»Bà Bî|BaB§ÙBé B À`B/'âBÏÞB„y+BµY_BžÂ`B}ÚµB®dIB[tB¦QB3 ¸BX1cBOö©B•µB€LÌBe°B~ µB"ž B,•ôB C'B#'‰BBPqBÏB,:œB*½×Bû B&ĉB%°’B=ÝûB;t­BðdB­Ó’CêBò/ Bó0BBï—BÂcB4z$B¬B#€BI´B„bwBn<¤B„¼B—‚›B…g Bkf¯B%uB*I~Bž„B;íB¤äB½nB,ýÌBÚoB$âB¯ò\CÿCC¥ŒC2CI¸C¬§BEcðB%$1B,KêB>B4è·Bk°¸BÂõB¢üBÓBÞØB³ÉB;ÐûB yB­YB*Ö×A÷éäB‚õC ¿wCþB÷9nCbäBÚ‡KBHBB^FBQŠB/D~B4Aëø5B9ÉÁB…©dBqB˜‰–B‚ŠZB”âúB–BsdAü •BE…Aôø B7Ù™B HìBT‘Bo.B~BZ„”B.âjBt¨B.ejBUÏÆB¦ÝÙB˜e B¡tÁBÓ;B±¢’B²½C YC5®C2ЦCM±CBÚå†BNøB'7ëB/¦‘BÓBaAàlrBRxB&~WB93BGAæÉJB-Bà´AëòpB(£aB ¼B(\9BÂîB?BG\BO˜nBA'SB9B-B93ÁB’dBªBžÄÇB¼YZBÕŠ`BÏC¦B¿ÂéB§B{ñIBŽöB¶øêBÌÉ B¼­BõiBÝÚ¼B¨™B·ÕB“éuBŠTB#«EBv½BµÊB gúAíêIAèW]B3…B•Bg»B€‰BmMÅB>ãyB3X@BYË¢BB+üB7û"BPDBUÞBfW B+FxB+1]BIB#,B&PB.ŽBGøBYÊB؇B!é«B‘?B ›B6B2ÇB}1B=gB ÒrBCìBˆZB­`ÙB¡„TB‰fÞB²hoBnéLB‰B.2BS'‹BJ5*B„B{—pBŽB{ræB?ÝB$k&B&£kB2{$B?ИB6OèB3ëhB-½Bp'B0:8B,ê%BBDzB-õtBþB•BêBêÄHBìþôBÖ$BæŠBÉ•˜BEtÒB/ÇÌB3xýBA+B‹c B}ÉðBB¼B’š&BÊpBcWBhŒB6Á^B@äŽBË–BeB(aBÉÎB©øBG‚ÈB¢j²C0gCXcC!ùúCËqCDB@ú«Aÿ×ÏBªªB¼BB#ÈBk58B’/kB§…lBŠñ”B”¹B„wB½³Aõ[3B B•ZB B–ЃCDoCC °7C ¨BäÓBNáPBà§BO?B·?¢Bî]B ¬ÈB,sàB^4bBŽaÝB˜pÛB·[B¶”³B¿øŠB¼óóC EC0†}C.±úC,ÜEC!j¶BÆóB@œpBwBsBÿBh2B‡6B õ“BÉ3B¹?B¨BðíAèÛ5BÕSB®GB#šBâÅB‰ÏB-•LBe×B.¶¸BJHeB3=_BK]QBñzB pyB <öBí„B³¦BÚ5ZBïBÐz~B³pÛBŠ?±B£ÂíBÍŵBÍþBÚÈóBúBÑyÇB£ðB¯ã¹B¢” B‰ BõBH2AÌÀÿBÎAþ\öBÍÞAú÷AûB\£¤BjÖ/Bk»€BVkBp©BBŒB( BBZ];BkbEBeŠmBI¤õBäÂB6+uB œyB B¥BUTB#Bó`B,£{B4rBa Bù˜AãëyBû»B!6B;B ]Aí>®BQÜ(BNÞB§:°B©Z´B° ÷B ˆB‹÷ÇBAB"&¾BHŽsBd[B„õB˜hbB„ú×B_8\B>)âB(ÁBA(:BL6B4x(BCp×B ²êB3‰²B#ÜB'ŽeB#OÜB9ŠB °ÂBùßBšâBúfaBðïOBó=6Bë-ÁBÒ]B@^MB\.B"B]Ò«B‡ÁåBˆRB„Ì4B‘\‹BsÚB`«ƒBbóBHB/(Bd{BóB5¼BØóBBT¬^B®=ËCïÛC²C![Cf›C ,VBgKªB"`pBHÁAÊ=~B<¢‰B{©B¯¾hB¤ïB—»OB§ÖBˆ\9B0UBBÊB"­\BDÃB‘èíBþ[[CDíCWáCôBè¢ËBL|8BªUBÆ’AñijB#fðBÚB5Í€B‹"ÌBkÞÐBƒ~B¦+tB†Â B2¨²B,¶–B¢ßAóÚBBÜ0B?ÉCB\9B>5kBO‚ABë˜B#ÎAÖWB{sBBkBˆÚ/B©BB°e;B´ÞçB²hžB§{‚C,aC44)C5uC2$ C(onBѤÀB,B=Aé{Aþ]°Bó$Bõ¢B óB BêB™}Aþ‚:B'5ïB#JB À%AòßdAçBRBáBXUB:B'ëªB`êùB&\B7B]Þ5BJTLBÃB1š'B!ABUŽB!ß/B!AB6õBB&³B&³öB4B/S¾B#ªB‹mBkpB‹B tMBB(ÔóBˆÙ#*B)Q_B8¢„B ¬îB+€üBLuB dÐB#œB.ÁBÒ BI wBªã&BïsBí<¯BöPBë©RBÄ«B#”%BÈžAô"B-#ABp}„B¥&gBšŒóB•O B˜8BNŠ2BïBäÅAëR»B 2B+ú#Bš×B.úhB%iBƒÃB°†jCÚºC‡C&càCb³Cü÷BP>»BiÍB,A»ñëBB––BKB»õÏBŠ£áB”EBB«YkBxòåB-wÞB=;oAÛ=pB$‹BB.&ÞBˆbCw„CXÈC à*C&BߘbBx¶QB4OBÑÜAê0YB6âpBÔQB^!ˆB–ŤB‚¥@B‡{;B“B|]äAóÿâBCš3B (Aí|”B3?¬B"¥B@ê³B<¤yB`ÆsB,)AB"š%B%$$Aêk÷B­DB$;sBžÝÀB®±ªB—îGB¦vBœ³éB™¾8C yC<.C9Ö¶C*<C&pÛB÷äB^ºB ?ÇB8ƒBI BìB…¯B6 ñAþÍBAÿÚ}B"›B"*œAò¼ÎA×–ÒAᎽAýÃßBÖoAøpjB-BüBVÞáB_p%BzgBkâ­BBÇBôcB G½Bæ±B‰u{BÈ*RBÛ;BƵ?BÖ¹Bb¸ÕB?väB1PÉB'û_B*UKB&B ²ŠB9©RB!i¥B?[BsB¥°B2:qBmØBOÓXB¦kBýH Büþ{Bã°œBçȯB»ÆÙB+¨·B#“BùöB Õ(BnôŽB«J/B¤ ‰B·ÍB›Ä(BMw€B! sB õÐBxB B8‡æBF¥ZB0jûB ÛcB&©ßB»ÅãC´^C¯C1)CÅ-C ñ BLevB4N+B&Aòƒ¹B(Ü^BrzBާêBª&\B Ê6BžmBpÒpB4¾«B9ðyAЉ«BbWB$åóBx%oCš·CYC*C qBÞpÝBeèB žB!×BAù5.Bv;Bc)BhíJB‚shBšŸÚBƒæBƒxñBlº]BßjB,‹£Aî\DBxuB"kBÒØB;,ÑBX¾ýB'&ßBHòÆB6ÎBMÍB€kB0”SB Ô›B†ìBÈB‘q`B¬ÈáB¹U_Bž–ÀC •C:)C4:¼C&Ê™C U·Bì™_B9'ƒB)ÑBéâB ÛŸB:åªB-ê™BK¿B…ÙAî²ÍB[îBfAßèFB(=B ë÷B7äBñwBäªB*¿BY>àBX™~Bo¸µBY ÖBH±cB ­B.5¸B+ÖBVíB/óB)\`B?èzB¿Â#CÔNCÉÏCÕ‚CRBüHÏB€ÚB2œ¤B€B`õBÚìB޲B4!B£GJB×ÿiBö)üBôŽsBÑýoB_Bf¨¥B·˜BÆ:ÝBÓ• BÔÇCøBÉë“Bžþ-B¿E#B®¢BŽïœB4ø|B¶•B(B!<“B-'B±ÏAêœæB‹øBtg|B„}ŠBÝB0>KkíBA~B¹†B:EnB¨hÛB¤)\B¯VäB¬¥Bµ.BµI÷C5™C6À}C?Ø^C?ÀÏC5ÔêBõƒÀBCüìBùÎAüèB0}BæêBLÿBB(T,B(–„BB£»BkB .B#¨üB ·±B¨àB¨íBD’BчBd$¢Bq»xB]'7BmZRB,ËpBÃãBÕ‘B2;¾BèBBÁIBÕ>¶BÖù€BÎ(ÇBŽÔQBsñÑBž)OBÊ/ôBÀ \BÄ ƒBý€uB¿úB©áLBÀÝæB¾Á„BÓ@B7Y[BæWB'µ…BÔB f_BÁ»AîÔ-B!$ÁBR1mB€ÐBv´ÂB=ÀB ´B*ÔãB$J”BOŒB2²ÚBGÞ BˆAB,J BÖxBïxB¡B'¬ B [B–‚BÚ-B/K¢B JmBLBÆ9œC ¬C§C† Cb BíBÁB)VB|ûmB”›=B‚B€8€B™Œ#B3>AîßB@½B2±B`BOkBàJBåVìBæ¢BÀ!óB‡fèBŸ8B·¢ôBÎÉÜBÙg)BÿÞABí|B¬Ÿ?B¯X]B­“B¥†BjîB>BýùB´Aï6]B ø”B"ÊìAäzKB[½8BzûƒBLÿŽB7·•B%þ*Br€1B5§ÝBAÑgBkʵB*_ÎB¦B ÜB8iBC96B7DB(ï\B-‚åB÷ŸB_B-B&Š?BùOB½ÿB#r¬B2*•AûýB=#B+HB9xBˆ:±B í·BÚB—[¯BŸ6BBŒa™B=B>¤BZ‡B€ B’&„B€Í.BƒUBR»ZB'B7ÏB&ô§B* 0BæÞBù™B4ÿÕBL“fBBEçB:|B&lB¼ïB)’×B,ÿÃB¸ZÇBíÌôBñÓ¹CDBò`BÁ¿B3å$B$ÝB4ÊB3¤¸BŒfgB‘«ìB…ðB•ƒB‘‰NBOKŒB'ªbB’ªBSB©B7B®BAzB/ÏôB/„ôB.×àB¼6ÂCLpC¸˜C! Cp6BçÜÄB4fóB ÒB~B4þßB5¨B¡_$B²B‘UaBŸÓóB˜_ÈBŠ}ñB~Á„B5ÖBBYBöÉBBép!B'¥“Bß2B6-B$ÕbB¬wB))B&¿ÄB2B<|B$ÚBÂ4AÓVŠB##»ByFBU6AìøB MÅB%‰1BjþBi›BròB†§ABqÍ.B,ÌÍB ASB.oB™9BÏBèu§BÔÀyBâ–JB±ãB•š+B²ôBÖøCBÌZzBç]BõƒôBî'WBÁ[•Bµ«ÃB¡‰sB—auB'‘bB,ŒaB1‡`BÈ•B/øWB) 0BäB ÂæBj¢B~^4Bl&"BøB5ØB;r‹BSäB?5ßBZ9ÜB5¦8AóžB4(WB!½jB8ƒDBdÒB7¹B ±¸B"ÝDB$¥ûBþ_B )ÔBíÍB_„B%CVB4N¸AÝmåBìBï+BfkBa7B¡ ŽBŠÊ—B£YB®RºB‹^B4»ýB;óBI«˜B\õB èB}@]BvÚßBb;BHî,B ½¼B-¡ºBMBÒB7“àB›´BÚøB5JMB0ekBPRyB8#$B('B 4BU[äB«CŽBÝSßBõmBñ:Bó5ÈBÁ=B;k†B#4B ΘB's Bˆ—#B¨.žB‹Î6B¨¼íB¡¢©Bn+ÍBDfB.XkBEæB!€íB+wáB.nˆB*gÄB `wB3þB¤ƒ®CÑCë2C)CâôB祱B'-ÏB/­ÃB4õ¯BK±ÜBPB•BŸÏ[B­f0B´ŽáB´Bs:B6F9B*ãÎB$B6dB'*ìB–“kB÷Œ[CPCÿïCt½BáùÅBeüB/”ÃB-¯0BœpB«B%ÜOBPõïB“?úB“x:B•U¡B¢{øB}ÄBD6{B¸ÑBHäB BpBêmB@0­BùàBnrôBR…ïBhDBBB*¬ B ífB;ì_BžˆB¥:^BÂBÂBÉš^B eÕCrC0±½C.ôÊC=¦C-.ñBÈÅbBGfÓB$>ÙBÒšB¿ÑB(^B¾B>>šB$qÏB(T B'ÛØAæÙ›Aý!B&N»B%vbB”ÈAú‚HB&¾EB7ÆÖB’“ÝBzQhBpC`BV©ŒBvÔ#BKNÒB_÷BI§¿B¤< B³ò&Bä¥èBâÉwBæÙ]B˜>WB”î¿B—KBÒ[:BÏd“BØVyCBØ~_BÂä•B©lãB¡+nB•kDBV`xB£!B'× BrûB.hÃB§¾B3BBJ,B``B‹/BræÃB3sBMºB3ƒæBdñ B]dBBL5BE›YB!ÚBJÒôBÒmB7o†B)¤œBxßB?ä!BÏÑBR}B¨ˆB+*)B,ìAàª'AùÛÕB 6(B&ªB*åB ëFBF9ªB™“¡B¨ÝbB˜?6BœHÏB—ó­BqûxB jWBâ.B:=PBiDµB›6Bw5íBtF÷Bom BfúBÞB5•B:îB6¢=BqòB™ÌB7råBºËB9`)B2 eBÒëB8ŒBW–ÁB·&¬BòqöCBã€Bì)BÅœB ýBSÍB=/B#oÔB‰]B¬UïB•§7BžäBŒn*BE"»B 9·B@?ÅByÌB·B$OÝB ¿^B+µB)ƒ˜B>ð2B­ªQC}þC„>C$ C¾1CiŸBa‡B-ZHB#x{BKÏaB!áÀBŒwÈB”¨iB˜ÚíBœzÏBª.BaÃŽB7nBÆB”B‚üB3 ùB˜žBú:DC É›C ŒÊCé Bù•\BaA¿B ÍÊB#f6B×_AóĶB%UgBZ8ËB”QßBzEB—@ZB£©¿Bƒ)“B‡A·ûB ¶‰AûÙïB!xòB$ãñB^hèB“þ8BXìBA@€Bi«BDùbB¨8B¢üBRKóBžÌŽB°ŸB¼ÿNB³Æ¼BÁ3DBŠCŠ7C!°C9t5C8¹1C.ÅšBÆttB* 5Añ¦gBOBÃ’BÃWB’ÌBhUB.÷¾B 9‰B ÔAßYÌB ‰B#Ù™B0° BšBî7B©sB?·;B€@bBlB…„Bx«÷BhOƒB3À½BÜ`B1ŸŒB’ØóBÁ÷kBÛüðBçZŒBá¯B§ÛÈB{+cBÆeBƈBÍKBÒHUBÿ7/BÒg”B¨·~B¤”\B¬ÁŸB˜>­BUnÕB)ÆçB pBIKB+ ðB tëAû¡B8ÐäBˆ¦¥BnsBaEsBJµVB;BGjçBN«BuVŒB,©Bth™B(;B+ÝBºB§ B3½—Bê{BAa+B+÷B3 B .B0Ä·BÂBeïA³“ÂB‡(B :B-äÊBËlB6ÿcB™èœB I-BŸyŠB›ÔŸB—U/B€°BE B#™~BfAßBˆ²B˜ŠÌB`‡ˆBoŒ¶B€ß2BoB&øóB¡FB)iB)ôiB)ÿóB-Á|B%†ÃB µäB¥(BRB R B7÷çB70ÝB´6oC“RC \ÏBåvBçfºB¹:B!ÍBßáB/—­B!±B“ÜB¨äØB‘vMB‹2ñB› BIÛ³B$'ÍB)gB0»ûBNBnâBQRB)É$B(ËLB@B°0%C¡/C ,C ÞŽC ;“C ¹ÔB4þ^B 3B+.ÕB,I†B?ùæB‡íqB¬5fB˜y}B›?•B¨ ‰B†ÚqBLÝäAü!ºB#7jB±BEAÑB–Q‘CÝaBõT•Bù"žC—Bð©dBJ6BaBÔBXB½ B%eB;D!BŒ_çBpÀBB˜ìàBŠ0ÅB'ÌAºOÅBHbBveB {´B8ǘBB}*Ba2¯BoeJB8EÉBrqB*LàAö“B BBïB”¬åB° ÃB®ýkBÀÈ6B¸}B›ËøCmÃC#i CBèôC/`øC.¿¬BÎʾBcëÌAÿÎB'>/B €:BÇBñBÁeBƒB ÈB—íAãªHBAcB;cBEB øB ³0Aû!õB/³B]ÖBWEXB^ B…ùíBT7Að{ BB5¿¢B—ŠB¸nBÊ‘~Bè¯BøûB´´àB„<»B¡DíB¼Ù÷BÆkõBÛ]÷CZŠBá=ÎB·HB¤+;B¥''B‘àBQy²BGXoBXB¬0B-Š­B BZãBƒWBwÙBqönBUê”BH‹!BM^óBmVlB^©Bf¿¤BP6Bb):B-Å‚B$Ø÷B&øÿB(3´B#B$B ÚB—†B.¥B8nJAýŠB/•æBAï¸vBªCB./ B8B« B#;mBŠTBŽÞ B¬*ñB£±NB£¨áBäìBb×µBF!ºB.j–Bn}nB„ÿaBа–B9ÜcBSB|î‰B[âñB uBãB^UÜB)SµB7ŸPB+ß¡B ýBm}B BBhB$H]B#2zB8ecB¶/-Ck·BÿŽMBírABèq}BºWB=ßOB+.BCM°B;¶mBšÿB›4ñB—Ø^BŸT:B§0>Bt³B*kƒB–BB0‚B9Ø‹B”ÀB2{îB‹ÂB:ø BË&óC¬üCêCP5C)î:C'ÖBeÔ B;ÏBKXVB>¤BG uBƒ B§0¹BŸkNB­_äB–$ÊB‹©%BC¦&B),HB+¦åB(…ðBXÅÔB«§C?(B÷¦C&×C ¨¶BÕ´bBJZ~B]¶B,ªƒBåNB'BÐ]BD“B‹ÂBpè©B}ÄB’Š­BŽLŸBMTþBMBHAî–+BßsB3%)B;½(BE7B[°ñBN!ÌBl[GB'oAÖ?jB­8BQžB‘õ(B»}XB³'²B¹¤ÀB¾çB¢ ðC©C7ýC;–iC1ý4C*¤pBçbVBZÆTAô± B ×B( ÜB.båB>ϱB_~Bñ|B"½,B1– B öáBZýBåêB pˆB”.B ¦AþœB1?–BFšáB43BG!~B~ðõBH'Bb·B=’cBX€™B¯ç÷BƯBÊOBîKC²?B¨ZQB}ÿB޾BÓ,OBÅÇxBãK9CÈ1BÕs{B½³5B´·7B§‡B•—rB_Ò¡B=á;BB†Bš B ŠCB[8B=Í B"ÁûBNà[B‚„{BpNýB!`,B"'¿B6ÈÅB9jTBY9Bx8xB:!—B&B,3-BP*B=´ñB ¯üB&$BókBÅuB8åëB-ÚOB3éÍB(ûïAåc€B¦qBlBkB©+BëÀB>ó~Bt'B°8ôB«¯B¥E B¡œBk£BK-†B"ÔµB<)NBQJèB~U¥Bl±B4…ŠBòµB0~ÆB@g×BBíþBDøBñòB0k‹B<:BžB<¿BppB.©BTžÔB¸;qBòGûBáüÖCâBã®}Bµ4qB*-yBy.B%Ä B1—‹B™zBŸºÜB•ôñBÞæB—BX›úB4üB òB$¶oB(HÛBeB1qB;ÀB!fBC39BÂøôC&GC*ë:C ½µCèCíBYtSB9ÁBMÄüB7^bB0mwB§ê BžÜDB–Ô€B¯ÌÊB¥Â›B‹PéBzB'2Bœ¢B L/B4;B™±¬B÷L—CÜCøCO¢B¿wÖBh}ZB*¹ÛBƒ^AÌ‘B ¶¯B1šmBC`jB‚®WBƒW’B{ùÍB’à|Bˆ‚B-#)B"+B4×BÔ0Bô¯B*£B8:“BWëBNLB[¦ÒBU×SB(énAç”ÛBÓqB[ŽÉB¥SŒBà %B¾B  0B­iB™°¶CàC/}¨C6ÄßC+^œC#pTBé8FBRÍqB‘%B s¤B!·!B1 BB BG¾®BüB,¯ÇBFÛÂB(-ïBjÝBbõBu:BsÀBÙ?B _ÜBG>ÌBmg BPÉBmðŠB†‡oBTüB@SBkBB%BisBÐüqBå™ÕBç¤éBâgB²°±B”OÊBŸVaBÚ›kBÓ¥±BÒíBôbpBÞ¥BÊž¤B¬ÛéBœ¢ŽBŠûUBJ²rB?í¹B$g—BkAÜÉgAçBç«B7¼B€ÜÎBp“óBy—…B E–B ’¹B6bBV&šBP”ÍBY•~B:’°B3§yBãB% dB(Š—BäçB æ2B ×3Aî9ºB $^B'uMB ƒ_B28Aú™õBKB¶B#„B`RAùt[B-b@B…¬NB¢ú‹B|‰B®†ßB Ó«Bt(íBBŰBA¸uBÔ…B>bBgß¾Bˆ jBz01Bir B5 nBH|0B>z§Bb9BJnCB#°úB+ ´BAPB-n>BVbÔB_B2I‚BéèBFŽëBÜjpC¶Bñ¥„Bþ‰þBî;|B„*B= YBä™B:m(BIsMB„kB£WB¦hB‘xB™ÂŠB\ã?BxhB$Ÿ1B"Æ]B¯›B7ƒBš]B°:íB²\™BܵëB¬UUB´ñ,C%Ù,C:C6ÌÓC(?˜CbÚBØ »BDZB CBR¤BýBÄbB(³ªB3B Œ9BÔàB-¿B2¡øBéÕBKÖB Ö6A÷hîBèB'B3d3BƒRÍB…õÍB…}œB…÷>B`0pB/lÑBtB! "B‹sB½­µBÚÑÈBà¡HB×eXB›©BšOgB£ýÃBÑ­ãBÏ¥7BÏëhBÙrXBß ƒB¶yB¸ B©~äB‰ƒBO®B=µ‰BÖUB‚sAÐö¦B΀B}B*âQB¹âBz2:BjpŠBŽB*\-B#ïBeÞíB'^€BKÞõBHÆkB=+ØBätB1ÞBBš%B5 B/UjBûB*ÿJAÆÕBåB 5B#MuAú`ÚBÕ_B"3^BËBõ‹Aã™B$ÑB…ŸxB– 0BíB¨lB xíBpÕ@B:Ò\B'Û‘B?2BsþÜBƒ›…B•ê‡BPx§Buë+B0gB0 ·BI÷B3¯qBhK­B ¥³BE:BÍ2B´BQÍ B6Y,BKƒnB0QèB;fBØC \Bù™²Bì}tBö(rBÀº™BJFB"£B@—GB:K¿BŽ\BšŸUB¢KEB–"ÇB­ëBe—_B$±óB.uòBI#¼BAïBxYBß[B1ÆûB.W-B``BãZÿCWC)¦OC(>CsCùdB%4¸B§ B#I`B&,ÌBVÄB‘4HBšÑUB£¿bB¤"B¥á‰BUB/¶#B• B{[B2IÀB7D¿Bœ­KC¼Cé·CŸÖCìCb0B2_ÞBY„B'¨›B"§×AìdFB1üBHÒB‰ ÓB•u8BˆºBnµûBXÀ×B&hjB)xB>Y>BhwBeBÊØB~BrŠ¿B_'LB} *BZ!ºBI³B5ó?BI‰¨B:)!BŒ:B¡OYB¼tÙBØ.mB¼!­BªKWCêC6)/CCZÒC7±@C#êHB½‚B3)ÊBßB2:BíŸBRBSÆB+gAB³Aüö’B) B—0B2¾BB²B÷€BìMBÆB¶§B&vÕB‚BÓ‡BÓ@iBé6ƒBÓè3B¸ñUBÀë¢B·~.B‘—ÍBEKB.®­B0›òB9\B$W‘B5$„B•ãB%ÕLBˆ‡B¶2BaU‚B "B?(æBB?…BQ"›B8¹uB_3BWjµB9VÑB@§¼B=édB+:XB,áB$ÃB‚B 'B&ÞuAÙú+BüGBB`B€&BÃÄB/5RBî¬B–@AþCïB:ÁB‚œNB§ÿ­B˜fëB«~NB•.LB^ÔB)ÈVB%(B[™0B‹ß!Bl†ÔB~‚ªBhýBŠ"B2™B8hŽB´äB!6BH BŒ&BuNB‡ÒB6f"B=äfBR¨»BQ¤(B"–ÿBD\*BɈ0C BïÅ–BÿBöBÿÞ»BÅ:DBO\€B%pÌB:N"BõB’’BafBë¦C·‹C'a-C)ŽbC”ûBýä{BN0B+ÚB+¸B#™¦BY¶BaëtB–­ôB§ªBª]B¡ YBY2ÄB(Ñ8AÿbºB÷³BúžBV]ÅB—³~C ?¾C!NC)C ûBÿ·ÉBTiÅB9-¬B)›B!ôB~«BŸ‹BhsB„²™BžV B˜Û)BˆÏöBvÉB+ƒ›BíÈB8¢B  åAûØöBbBXÓ“Bc•jBlY£Bk<B;ž¬BG,[B,—BU¥'BJwŸB—  BÂöB½E¼BäÎB´ÝVB“uCCDVžC0ÅAC?EüC'$×Bã"BÍAçã[BаBrâB1B;U˜BgB,BŒB$õ¹BJ Bç(BªPB`ØB%ôˆB<÷B.÷AB3ô,BzGúB|S B‹›XB…‰B|”pBD8—Aý)B:ÍB‘©ÒBÐÇBÒÌLBøÃüBØãnB¢ÀTB„„rBWÅ×Baà[BM%£BWä—BÎÇ1CãûC ²ICp”C§ãBÄÏGBJsABX˜B=JBqÊB‘bãB’ì£B£ÈB¦„}B¨ênBZÀRBG`¸B šVBEm®B=¥aB(nŸB91õBH‚$BEŽ_BKårBÈ–C-CGyC9CêëC sBoÜ(B¼ËB//wBgBVÔzBkø÷B ¿’B¤›B›ÙºB¦»LBrZBÓ¬B/]žAÿ¼B#( BL|hB—Š]C ôC’ùC"¦BÿeC³çBX?B!~ªB|BxB'ÜxB2L”By¹%B¢TÜBŒWB|¹jB¥ÕøBš_\B8'B_ÁB)ÎŒB ºUB×ÒB ¶¸BCtàBGÈ‘BS gBP|qBLãKBZ| B ÌB+Ba>ÑB § Bº[ÎB¸­ÿB¼ÍHB«ß£B–â”CprCDC&ˆ8CA^¢C.Ë\BåBIpšB/ÖB¹{Bþ¬B/¼ÏBFGB“ãBƒ kBqžB„‚ùB5nB3omB:ÍB>½§B+ã´B®±B<[B!Ù„B7mŠBNH|B(jHBF½¹B'ÑeB>°0Bi_BÄÊ9C’C‹HBô»¿BúÝtBÈ<éB) B  B9Ba6¡B÷nB•.ÀB‰CQBŒƒ‡B–ñ·Bc|[BSo·B!ôpBK.BBHŠMB@”ÎB-éBQçB0OnB1#îBÅ‘½C ÓCð‰C#‹¬CÜCò€B…€WB?¢B;ÄB!5B$æBmSB³:B•yÁB•7hBŸ7úBj„ZB<vBGB#¥"B#¯µBFŸêB±C›…CVC ÒC BýýïBh B2ŽnAõþÆB#ˆIB)ŒªB%>B…E¯B¯±FBb±zB‘m²BŸBœ,B9dmB r¯BèB`óB#…B@“BIÊ}BZpûBK!ÂBN`‡B{¯‰BEqþB®èBî¢BIÈ‘B¤ºB˜IñBÁé¯B³-B üaB™ JCïACH6éC3­xC;«C*C$B×!fBÇ£BIˆBÛËB(ª´BFÐôB@AünÙBª"B7ÍÿB!-gBuöB©#dBÓ0EBÓž^BÜKBèB±×FBÇB¸i{B¨ú‡B¶Ì€BÑÍvBôzØBõk:Bà%BšÊSBÏ™…Bl¤•B0AøB"BÆB 9¹B3§2B&1 B3aB,B„òB‚ÛB†NBËrB;JcBiq†BBÆ}BRÏ-B-áWB5L*B.4ÐB2ÇdB29cB>¾B;)B(éB=c³B;îBù}BB ·›BéB¢•B7§¯BŽžB=ëBYæBR¹B<ú(Bšœ:B¢ŽWB•¿ðB™% B¸_B†žB)¦‡B''Bhñ_B~ªB‘@ðBˆ†ÏB…j¨B~åŒB2ÊBO§YBVÈXB9>ÓAúÇ“B3N£BAè!B4û{B9LIB#ðþBI³PB(&ßB)B[ÚkB° œC¯Bþt'Bø(Bü¸ãBÛGÙB2[^BâHB2ˆB\»jB˜À¤B£ï"B€Ö‹BŸPB‡n BMiPB6kÀB>sƒBBðB«¨B1žèB9\¢B&EBIYäBnø¢BÍCˆÑC"ßKC&|JC£ÔBü3¶Bz>5BWº§B3$TB9Ì,B)À}B 2hB°¾BŒIÉB«˜BsÜBS-EBB¦ƒB:ó\BDÀøB²B'í/B´ƒÖCöCS¼C›XCQ‰CãaBs¸B!ëBäB,(ÕB ŠB*êBŽ“BŸ÷ÁBƒ(BIB£+ñB†ÙöB9KSB%2%B/—­BcFB!RÍBKl¨BNg(BSB5'¶B‡„¢B|ÎïB[g B Ì0B%`MB:gB²ôB¸|B´—BÆä'B¯0aB¢OÀCT¿pBIÏÙBwbCBF+9B,¾B<1B PBNæÔB;…QBFs0B0qB;¤BGêXB5Q]BDޤB#n°B©ðBë˜B+ˆB¨ÌB*Ë B°ðB7+B%·B“OÓBž'ŸB•ÛhBK{!Bo}BuŽAB…ª$BŒý"B:d#B:½B2ãóB6eB'ïB8¸ABU8dBFסB7Ž-BMö´BcåB7þ®BL‚—Bg1WB¶× Cx©BþÏ CÏ Bóé B»ÛB#¾Bn©B0VB95ABŽàNBžVB©qBšiªBŒ!çBJÑæBEÅ—BnÒ8BGT¡BÚBRB^w±BSÙnB;©$BcÑáBÇóÎC ×C)õ>C€HCÔèBûÕ€B5Ù¤BN­eB"×OBBæBR(½B• B¥r-B©!ìB¤9­B¡TÐBu sB¸EBI:5B@×BCdñB*-0B¡%³C†‘CIàC+¼CËjBýsíBNÁ–B†xB2VBEðB5ÿ$B2!¸BMñåB£ŸÕBœ)BBdBžÅ†BqÂB'B;·B/k~B2ÌàB'çuBI‰ BP Bq.BPŽ)B\³ÅBbükBFÉ5B!vB3¹jB<’ËB¶„[Bº¤BÄX¼BÅe|BÁU•B­dNCÔC;Â4CPˆCAuUC9\CBÝUZB2}AîŽÓB+²œBÂyB-œB]ùB ‚B<’ÊBŠB $úB‹BB=B Ba÷BS3B«B+—°BW«PB‚ãBHBXßBD ?BGB\BF†ÜB@ȬB¤PÁBÀcFBò|¹BïWëBçeÉBƒ BuÃ#Bª/¢BßThBÀHÕBÌÙ§Bí*9B÷ÕxBÍÝCB·/B¸Ü[B‡–íB[MB+°B|QBSz=B»ÐBL9ƒB%õbB=æ7BS!`B‡ ŸBW™BarB-²Bg&BnóBXyœBA)—B?€B_YOB¦åBLzB3!EB-·ÄBDâB(ÎÖBD4²B05ÓBs—Bš'A÷B’zB+Ì‚B&€ÁBœ4B(ùB uFB=©nB¥â5B 7ñB›{­B­.B–€»B‡º BM¤Aü]ŠBMƒ`Bk޳Bfï B׳CEí“D6v7BaüµB/!‚B2.FBO|B9rÙBBáDB?¯õB1„B9¹ BBmáBjË‚B"ùBIݹBJHtB²ù-Bÿ…ÂCÿ‡BõÂ?C½B¶^ãB9£âB0pB+ÃùBT-BßBŒÔÇB¥RyBš"B‹l®BjSQBQ…UBGö9BD+B. ªBHjB<ɧB^ìB?ë“B:·ÙB¾š’C¸ÒC+KC[²CBñ¯vBJB¯B+$[B;§EB.Æ*BCÈþB­šBšÐB¨ääB™µgB³¬B†œôBßéBEîþBÛ,B2à)B'!B©ýC¬TC }ûCèmC×|CÏ-Bj,ÛB( úBßrB% ÒBA¾áBŽB_ŽBœþ¿B›ÁìB’ÝB“Ò2B‚DB3jŸBXƒ¶B,à–BR1rBOB%A¡B4xÐBnÒFBeºeB BDˆB)ƒB ±¦B;µ±Bkå=B˜aûB§s/BÖÞ“B¾÷\BÈÁB£×%CǧC?ÆCM¦~CÝB mB¶»”B¶OhB¾öÉB·¦¬B”"ÞC±ûC3ÞvCHæCM=áC<ÉßBÜŒÎBGD&BTYBcóB&ÅæBœB|AûšïBBB; äB%öNB\’B†ÞKBµ“yB›uoB“:µB“$—B.¡B%ú'B#Ó1B1йBî B3B D3CÕ¾BÿÍÔBüD‹BúòBÏ-MB`žB4œLB¿ãB1SêB>ËûBAnBb°BæYB¸Š BÛjxBÖKjC ÎùBÛ£®BÏÉB¤sZB¬šØBa:bBOEGB9+šBdøB «RBH~«B‚ÙB)bDB—½BEB}BeBU äB05 B_…BY¼,Bb'.BVº©BPάBeÆ B@ubB:ÌŽBC~‘B6áäBºÅB¡ B,MB+ôB."rB,¢§BôwB9Ò!B ,B"BÊB4{B/BZ!BC@4BCäC,ôBC-lîC!ªBâ)NBUWB2í]B9Bh0Bj¤ÊBž(B¤"B;2B«QpB‹ËDBv—oB#sÖB#‹àB(?¸B&Ö.B1˜B«»°CS®C³-BèYpBù<B×¼Bƒ¹hB8fB'YéB6ÒB/ôÊB 9BQ+§B}w Bš†B˜¬_BšÏB“¸–Bk¬@B Á B!™ÌB¡tBQáB(ˆB]\ÌBB)B’íBDnB_6ÕB<Í>B @›AïokBO^B¥Õ˜BËè¯BÁj¢BĉBÇÄ—B±€ C&C<«C6Æ­C8Æ6C*jBÖºßB5%¢BNBâNB.B;ŽùAôµjB#'àBO·‰B$‰¸BWB €B%bB·öB~ B ldB-dB‚&BJjÏBp•ðB}2ÇBS)DBt"—BtHB,,†B$wsB?½B¢‚¢B×ÜKBÔ3ÁBäÒBÓÉýB¥µÝBq˜Ḇ¥BÃtDBÒ•UBÄÑÉCå_BÏçGBɼëB¨MÎBÇrÜBpC?BB:©B+AèAþ¯BB?ŠB4D¢BÑDB/c˜B aBp®B‘çñBr¬ B-*UB4{BM$BcL7B@àGBA"B¢ôÎC_ŒC€…CÁC¨‘BÔ¨TBsÈB#n†B²ÂB¬¼BBœBâBL”&B÷CB VB¨;ÃBª¤—BŒó¥BW3_BëjB!~_BÈÿB.ÄpB,>IBCM(B;wdBcBÞBTxVBS[¹B=˜•AìàAæÍB3ùB«9B«8ªBįáBÖ6hBÊ ŒB¡ŽCèCFÏÓC;¯ÂC.¦C"iÒBÞB> )Bo²B)c„BÒ×B@ÆAöÖBësB3eB, zB‹°B'rgB'†™B!¤B$hBC»B¦BÑÂB5J BxöŸBnÕ\Ba³ÔBB;BpŠB,,úBÝkB3…¾B›#BÊ„/BØ'…Bß|pBÙìgBˆ¦°Bj«BªÒ¾BÐÕ÷BÀýºB³ÒC ¢ÓBàÌúBLJÃB¬®´B¼Ä{B‡ÉB-„BˆB|²B ÀÅB"B•ÍB2h*BgÆB}ÍEB6‚Beg÷B‡fBU„BX”Bq¡ÐB_>BT•ÈBRVB9nJB.·B1*žBÒBlBBüüB$£ B5Z^B1¿WBB©‡BÝÁBê!B'zXAÝBÒ³B1±BPTÃBLP1B¨Ý‹B¬ :Bž¾BªýgB£lcBˆZB$ B4B? qB]×B‰ÞC‡˜¤DìkáBƒgKBi¯ÌB5\B9hB;6·B¥÷BDX5BHs+B,_¯B ZB6#®BGRµBËeB$ÑB7é†BÀµBöÉ®Bô¾ BàIC†BÅÔŠB8I­B={B'4BPO©BIB¡P}B”xƒB®˜õB Bv¥B1­`BNˆÛB:rB*þÍB:ÆB"H B@¡@BDaÓB=rÔB¶à/Cõ¢C7ôC!r¤C$æÆBè 5B^ç;B›5B/ë`B/»BR}ZBz¾"B£=FB¥èB²fƒB¢iBg¤ºB3ÂB£½B(Û°B:¹·B<&#B¦2öC þUC«ÏC¤GCpuBÝiB7ñ7B ËÒBwgBÁHB¬©B4ö¸BoÀ®BŸõ_B›EÛB¦„²B†¼-B~g¡BEZÜB1h%B&äÎB%+uB *úB!"ÅB@ëIBañBeþœB~æŽB\½cBHÅÜAü¦B)B’BVÚB‡"B}¤Bµ¿¹BÄ;hBÁÿKB¤UCÜC8;ÍC9ÃC67C,P›BÉ´ØB?ÓB*zB*cAº·´B¸ BJƒB îÙB,^¹B ‰pB•BÛBnäB*$ˆBZÉB"B-ˆB½BC%zBzÊ£Bm2ÖBz!gBUKžBPÛB7ÈÔB0{›B4ÕB¯Ë5Bà £Bù™ßBèåìBÞ2Bè_B€í¤B£ˆÁBÇ›ÓBÊÜ„BÌ pBý}ŠBÚ·¤B´yB½‚AB¹¨3Bˆ:cBFúB*˜áB ÛAæ`™B ¸—BrÆB ¬ÈBüÅBj»{BˆeŠB€¹xB"‘€BV~?BK° B>Y9Bn\CB[”Bcõ°Baj1B;GgB+TÈBÍŸB&ôBE~B˜MB&áßB.sBhB)®›B)ëB@ÛBÃVAêËB¿Aí B<šB[±B¤’B¯¹íB¨’B¨_÷B¡§LB„ÔóB"‘©BYúB6‹B\ C(l—D‹½D‚qÅB‘6BL¡B(„»B'úEBU¢BÎSB+–NBKqBB«èBû B9`BFöñB .B%ŸB9/B·ƒpBýœCíÚBâÆhBÿ­B®· B/ÈWB0=¦BE+TB&ðãBÅhBÊB¡QB¶dkBš'—BP B‘ B2ºAû±qB ¥,BóxB%Y2B\nBMÌðBK`¿B¸E0CGC~ÁC)CÃEBøx¹B1 kB <™B+ÜB÷,BF­ÝBy¨ËBŠæPB°•gBš(B›’’B~éûB8zLB)KBtpB"yŸB?ÕBé CÈØC*C<*C !•B÷KÂBD ËB7]B3_BëæBAÑB>sBi:BŠÞ#BŽ˜vB"B€JtB†:¤B,dB4ÑÃB"†B0I0B ÈûBHyBGõÀB_~¼Buù‡B|5­BV†–B0ˆ§AórB?OUB+cB¢ü¤B¯DB¡WB»LªB« ¨Bž£/C³ÉC/’£C3køC0ÑC(—aBâƒBø½B BEC^AâMuBè`AþÇÓB&l2BC.­Bâ–B¦ùB ½qB @B¸µBûB/$áBô)B( §BMÀpBSƒBSŒBmüWBQoBGS@BUgB$ŠwBO9\B­²vB»ÃjCågBëqBÅ¡^BŽBëÂB¡ÆB½¥BÜxóBÖù¾BܶBÊØñB´sÈBÇ?OBÍu±B‹Œ¨BJš¬B-×;B<ùAðQéBýzB+|YB rrB&ÀBp@BzßABg‰BB*__BEItB/m¹B<)B…¯ñBGÍEBn`B81B&>úB&dB ÏB:¬B#ÀêB(ŸKB,ôuB7îÍB éŸB!¸B@4dB*­AñEïBåB" OB õPBÚóBA!bB“PB¯QtBµX€B¯zäB C:B‚ËB?§1A÷GfBVsBjĪCru…DÑ*ãC‡vBBŠþBWí™BIfaBBèB RB}¦B3RxB>5BG^0B0­ŒB*]5BF¼¦B*w+B!RÊB5§•BÇÍÌC :*BòžBßœBö!ÝB²ôËB-iB.NÑB3ð)B+3¡B‘OZB›B˜ÖÀB¦­ˆBŽ‘BPÛýB*’B)ŽzB TÿB2ÚGB+ RBÆUB2©=B#ægBRˆÖB¸MŠCî[C'I“C!á°CÄôC]5B08>BúKBq/B·;B7ÏB’ÌB™±B­ßÕB•€mBPÂBöB3ÏxB#°ŽBêBVB$¾¿B­àPC]×C ÀBíH÷C …¥CþEB\rTB:æÚBy­BìâB…òB ²6B6 B„È&B‡kBŸòuBŽõéB‡ŒRB­B¿šB  uBêB û“B!´ÝB@W'BJ'¦BcêÒBVÂBe¹RB,µ4BàB"í]B'ý„B²5rB±rAB¿ ‰BÕ”¶B¸à¨B¦Ä C\C1LC5ÿ1C7”õC%1GBÝOŽB!òAÈ$B%ÝIAü_=BjtBÓ‡B4éB;Ü B-5B$-BéßB«`BˆB#¶B ˜NBa£BÁB4£øB>(BLÄàBi§BT°ÁB]£B„óAõ¡B=YB£«WBÔüOBñ¹€Båf8BÇçGB¦Å‘BeÚúBšG€BÄ€!BÍ…¼BÈX¾BéÄBÐMFB³¬íBÈʯBÆœBŒµyBw6;B.ÊÜAò~fB VëB(¢æBcCB êBÕ®B]MÂB€™ÞB[ðBs0B@è­B:Ï—B9œBq½ØBT;BaW B½ãB ð>B% ÂB7×BC¡DB7:QB,0 B.1ôB ’BLB 9'BÓ€B5DBÐÚBì­B8oB *òAð±úB<{…Bš«B³zpBª!B›úBœÄB‡4RBR{Aò Bu`B€ClhyD¿˜ŒBqžwBgÊ B-ÏÛB&>\B(§«B5Ê(B¿B:ÂEB2ÉäB-ßB9/cB:%ŠB8¡B3ScB&"zB5Ê(BÆQBüDBæ%Bþ}¾Bÿ2þBÉ;¤B%2B$-„B8ÀB>QÎB™>”BŒ^oB”‹7B‰B—ÌÝBNóB'˜ƒB$eIB“ÝB)w[BSçB!×pB²KB.^*BI¼àBÄ~CÖ´C&ˆC9C®BçžóB@†:B…ÞBÚ7B¼èB(–[B”ˆÏB°ÛFB¬:©B”‘òB…VëBzµbB>àBGHB®B ùSB*¼[B¶*âCÕjC ÓC ÂC DGBè„ÁBc©fB%ÎÒBÅÝAüÅB WBûqBXBt3@B‚+gBq¯B4ûB&âîBKƒ B& Ba¢çBJgÿBJaHB#ÝB(†9B&e{šBSpùBF¾B9ÏtB!åYB(öBCÖÀB=‚B¶nBzZB2‰ëBGTBÀQ.CÞBÓí\Bû½¤CŠ;B±%B B)ÐEBÄúB1BŒ5ÊB˜õ¹B’4gBŒ–mB›ÖCBZe½B3ÅMB?f7B*,B52¯B@>BD ÊBJóæBR;\B3ÁtB®¾¢Cb~C8óCóþC%¨ÚBжIBC“rB%mB,˜B2ƒ0B.^œB—”×B­™ÙB¢öÇB›ý¯B”dBnô:B-õB;ÓÌB-A B.3WB.ÉXB 'ŒCøCؼC ÷²CSBÙ }BZ¸nB2ªB4Ü%AòQA÷¿qB æÓBzBƒ©VB‡V­BŽ>wB™â¾B‘ŸØBOWðAú ûB*B|5B½mBæBF‰"BABC.|BCÌ-B>óËBHØzB&:B)B ]B‘‰?B­¬˜Bͤ¶BºÛBͱB®(¢C7C1ëNC=áCMd´C%¦5BàÃiBK©¢BÈBý–B-B7÷VB:pýB?B+¥AÈ?B-åB,£XBJ>B)¾A삇B^AB Z¶BšHB#d BV'3BcL”BF(BeB.âXB4)MBÀùB,. B¿ß¸BàˆÁBá~mBßåKBï&B£ÅB]ÚZB²qDBÀUBÈ3íBÁöUBôùoBÃP|BÍE„B§7·B«>|B†Ð‹B_I¨B"?BfB*"Aî‰ÁB`B1 :B\‚Bx'XBdÖ$B`hüB\lB«>BU(šB\üB\µB4úpB;ä±B= ðB=*ëB# Aü‡ªBËPB ñùB+î”ìBJ&ÜBW¥B<BE÷BGÿ'B®òB=åB0Ò¤AöM‹B,“ŠB¼ÊB´lB0é«B/B/Ï”B'U7B ˜ BèB —EB!y‰B!†øBK“wBƒ‘ÓBŽœB’@¹BÝYB­qrBMúÞB¬ÉBNÍqB<ÿÃCHìñDÁðEŠBŠ®éBifBJXB2ZÅB‰TBm›B),ÆB ÃåB%R=BÇÞB'o–B «B"ÙŒB4GA×ȵBM%B©¤BçËcB÷oBàî©BÞªÛB£±LB/m»B€ÖB%uÑB& B†‘B©¢sB€Ë«B£)>B€€«B@`BSÓB ÀÕB&,‚B&#ÚB·B8…B;ÙˆB-ð÷B+-FBÃ7xC Ý}C úCÒNC ®B÷æB=tB:MB(@=B—fB7È0Bdõ‹BŽNËB¢#´B A~BŽ•Bm´õB#Ÿ B×BÕoBBsB@5àB‰{³C –Cµ¥CkýCZ¥Bá|}B/.EAë9žB}oB!feBABWBM²ÀBš^ÄB…G½B…ÕBŒB†ntB,¾PAþدB@<›BGnéB^DBHBV¯µB5“B5%0B UBçtB"i B£B©õ$B«ŒZBÉÀBÅ­FBCóêC9CC1ŠlC`­C ïBÄãÕBVúBsB ÛýB7¬B9ÁB#1 BòB&`nB)1•B)G³B)ØäBÛÝB žeAü©BpAðÂìB¢BB.™Ú¶B8tBø'Blè³BœølB¦ßƒB„OuB”™B€µB |B B &ÀB ©…B™B úÜCÈìCÞåCÝYBþ´B÷†BUž7Bè¤Bˆ†B35–AÏ“âB BAœB•Ý­B†´pBˆJ¯B–9BŒM B%ÁBèB –×B1NB†ÞB(¢ÝB2ÖdBOÖB4 B&êzBF”:B&úBáÅB—öBC„“B/ÕBªÆB¿iµBÁ¼kB¾¾B°CzC6ÄÇC!¿C/swCýöBèÓBÆBÿBIB 2×B:qB*æ«AûÜeBS‘B$Ù¢B#ߢBDêBüB R’BÄ$B#^BýB'ýzB*ÃBKñMBDŒÿBvߨBO¿UBmþ–B1sBÈ.B7A)B¡kBËl³BÍy7BËÍÐBÕ¿B¯ÝmBsk B§×–B±#dBÏ£BÛ³„Bÿé4BÕº1BÑÈ”B¶&B±ÃBˆˆ´B*ìpB(!B?;Aíø¡B&¿AêB okB:BQéŒBwB]žB ©®BjòB@ü€BV?¬BPþB4ùWBV”B Ó"B$y¬B/×B îòB¾©B¨ýA탮BHBIÛ›B‡B>ã/B fB W*B ©B“XAÎ=¶B˜SAö½ðBã©Bp"ÛB©%ìB™ô0B¦ÁóB£ªB¢Aè¢PB¸ÊB`Ÿ C¤ãxE†ÄC\NB…“½B€Á!BFÑKB:—B"› B|B,E)B!& BD°B!Ò*B:^B(ÔB$ò*B.´$B=B\ð¾BTJSBãÖBz˜BY?B#y=B QÖB(u3B–Ž]BØEfBÝ“‘BÏ,B¯ýãBœlHBnÚOB³ÌâB¼>jBËyíBÁ±›Bü0BÂF*BÄáxB²!öB·ã B•˜6BB`BwúBÃ,AÈ4iB{¥Aà¢>B×TB"N4BwãBU!àBZÕAB+y+BOB>-øB:ðùBg DB;wMBK äB,ÄB3?%BnvB1kBs4B ½ŒBwõB" 4BpB ^ÉB&PéB T÷B·bB Ç^BýbAêHÛAïŠAûyB/ B/UB¯Ö1B–ƒcB•d—B—ÛB`´ÎB%–;B-ÕÃB:ÑËCį«E=}~B…×ZBŠ›ŠB;ÇòB&ÿB&ЧB%AB1áVBÇ)B(×áB+â¹B"ÄB)û:B!B+æ’B,ÿWB|dB%C‰Bº23C ü2Bú„BõºŒCìBºjsB`]B¤™AùÑ–B-jB…Ï-B”ÄB¡”BuùB~s5B8‡AëžüAáuAûÇ‚B4óB8[ýB 0ÉB–[Aí qBUFBÒŽ¹CóïC!µzC#œ½CîHBùl³B$ öB OB˜«B =÷B$ÄB“çÓB”ëëB·[B‰B‹ÕB…<B!6 B /Aà”B ûðB- ëBŒôûCÙÆC«ICðœCöÏBä]^B0ˆ%Bˆ[A÷Î4B®2B õ,BTBJlùB£8|B“ÖÿB™Z‡B•ÍfB…LiB®dAüñ–B ìBFŒAé²­B4M‡B2?‘BFWÉB_¿B;ÔBH«B¼ÑAÚ¤×AÙ°œB0‰B¬"±BxB¬5qB¹æ=B’ù\B–¯CÕÂC)ª¼C#=C7SC0“¸BÌÄ„B=nBÏAØL×Añ‚¬B'ƒB·”B[ŽB°>AÐA¾ÏÛBwAî­AùqpB»hB 5B)…AðèÓBM›eBlêÂBAsÝBMZùB€ý‡B;§ABsïBãB2q‘B–¸ùBß΋B¹°eBÈ;vB°ÔœB åÇBzºTB²_ÎB»ÖdBÆÐ{B¶–¥Bð„jB×Ä`B¨ÚOB±GÿB£›†BwhBIjRBÙ·AüùAÙ5ˆAÙñþB?^BžB¤B‰BƒH§BJû]B8Ž…BÉB;ütB\"ðBEÕýB1¤DB8”GBK5B&YTB3 9B&%„AúŸBDzBïÜB1òñBàB«HBäÁAÚöBšíBÚ+B,‡†B >­Aé~íAû¢ÚB/QbB‹EÍBž±ÞBšv•BœbòB–à_Bf‘¶B&ÕB.p„B$±TC¤-5E>qBz8wBu¼dBH¦BôVBMB›ÄB*R¬B‰dB9B,íûB)X¬BÆ%B%‰B7…‚B£VB¶ÙB2ÜBË*àBæd’BõS£BëP©BõšOB·Ž7B®Aþ:SB«}BA.•BzB‹pùB¬àBm0çBM B$ñÁB#`ËB|ÄB *€B¤LB÷B7 B"Í®B³îB¼CB°@ýC ÄgCÔ'CÇ3Cè BölgB7.B †”B(Ð#B¼õB âBcµüB¦´ÄB¡¨vB¨sfBŒç~BW*sB™êAñ†jAÌ¿ B- ñB„MBHC ?´CéõBòü™CBß×,BF(Bb©AöÀßB# AAö©ËB-1BO—B—K•BˆDzB‹)ÒB˜8šB}8¼BF°B-‹B¸¯AÕ­•Aø|B’ýB?‘BZ1sB]¹Bø¸BîýBê¿Bú öBÈ®ðB/ÊB®)B ÕŸBP?ŠBƒÁÊB–%óB‡0¢B†f;Bg½òBiB»ÅB!×ÂB×BøOB ·•B40ÝByGB &ŸB+$†B¤fCY CƺC’RCbBo @BWÆBôüBŒ‘B”ö–B? B"È%BObBûÍB“ÏB4qIBšC íC_CÇBùU;BÚNwBÕÄBæÜB ×BBã[Aéú1BOŠBFýZBAÿB/þB–5VBz([BbôóBIXAý AôËkBoáBõÑAáËøB8’úB_jBPp“BkgqB9,ÒBNOAåmAÉÕ^BQ×Bž+OBªµáB²¶oBš°íB¥zñB±D>CD C)ÊÀCB¯TC*¨ C)B´×$B/oB äB±QAüN}AÛ®—Aã BãB!¶B¾B îB,íAóA0BXíAî| B ˆ³B†YB}[B*‰·BMÀBU«ÿBQ5±Bh-BNŧAÿ¹|Aó¡XBáB³³ÌBʤ`BÒñ_BÎ]CBä™B©¼\BiêB‹_ÉBÄ`‰BÍ“VBÄeXBß'BÂÑúB ¬¨BŸÂ BÆZBpO5BgâB£‰B=&AàÄ‚BVîB qãAûîVAøÄ¹B`iJBT’DBUOIB>êXB2 BKž BaaÌBTaUB(C3B>1)B6Ý]B ÅÄB¢ˆAÜ7‘B)¿BÒB&×AúîBXËB MBYÖB+PfB¶ßB –ÍBGÄB(õB2Û*BW·B1zHB!ÀTB2ó4BßBƒœBFiB¹ó#CQèBí)3Bøˆ»CppB»B!iËB¼àB IB?ÐBŠ ÈB›MöBˆ…ÍB† —BŽú3B/yB-?—B-(„B‹B$7B,¾¿B54 Aè BB ¡BB­'B­Q}CC:ÎC2WCÓgBÜzB3p4B_iAþÈAüUyB÷Bl´B›ÏJBšä1B|°B•ãmB;›‹B$¨AÿyRB&Ø,B ÷§B1n¾B›¨YBý+¿C‚òC ‡C s¡BáöaB2€ÈB4ŸB.G B)p˜Aäš}AøÝBDû‰Be¯¢BªBÍ‚B|jÙBIÎB5ÿøAù?AâÎàB+®AÚ‰’AÚçÎB8ïäBFQØBbá]BV%ÂB[ò^B8Ë[AößgB ê1B ‡¦BŽ×–B­QBŸÀçB¯ÔÂB¤H B©VCBÿLtC>Ö&C=ýC%¤*C(·çB׃bB)U¬BžAõl?Aåy‘B#n#BuÁB5r BæÁB A±B¡ëB ÁÎAÑýAÃéHAû…ÈB9|FB!^AþqÛBCŒ;BYO_BsmåBGëuBL :Bc¹µB,N>Aü‰eB<'íB¥kBÅó¹BײûBÙ¢§BßhB¯B€JBu¢BÏ¡BØ›1Bå”ÑBñêBÆçyB¥ÁpB±É¸B—†-B·B"Ï{B®B*AÚ·ºB/ˆ4B[ôA÷BµwB[EtBvކBNIÉB:­¾B,Æ B@ÝÛBQŸ»B5[EBN-öB4ò°B1^`B§BÞûBùBŒGBÏBÎ)BÆqB$ºûB"±B3)Að˜B%çBS¬B¢ãAö …BnµB=ÆB!ÞåB–Ý“Bd[B•hVB”͇B™¤òBO9œBŽ'Aô}·C©qE)7¨C HÔB7ž[BHPbBGmvB@CÑBmõB'»AóФB$Ú†Aóp}B)B :B6$yB?K½B5á+B9PB8ÓBGÒlB±VÌBøÁqBö!ÏBó‚-C“zB¹€²B;ÎxB… BöB þBŠ‹B—G.B…<ìB…^“BŒuõBMBp¼BëÐB%³ÕBE¾²B,“qB“ÃAÚ8¼B B<·*BËQC?HC~_CROCÜûBì ®B>×dB"výAââBQîB?àBpæB–µýB’‚B‰ZÃBŸz6BK|âAñgVAû[hB©B#VBœ8B¡8ØCnzC #C$´CBß–«BRû&Añ1}B°©AÌÄ„AòÉ.B3BGeÅByZ3B|÷B‰HBŠV5Bb#BÊ B׈B)ÇBLÛBsvAþò¢B&4­B)T¬B~wBWV‡BQëþB$†B y¨BGvB'â{B‡Ú&B¤ÐB¼ÍâB͸BÈxæB¥)CÎCIS:C9w%C2ú’C-˜sB¸]ÔBL`B#­B t(BB2ÇæB+Ó"BÚ&AýþgB°äBºBAùz£Aåå0BlB"ÐBî¥B#ÁAòr¤BA¨‹BVBlüÓBhQ¢BU:%Bk\zB/uçB]XB?NŸB¦!BÑÎËBé¯B¿sÄBÎ B·^‹B‡v'B§ ÜBÞ¹„BÇ÷’BÞ „BýnB±’B²àŒB®ÕtBª«—B‰WáB(“hB+B³ôAù-¶B ÇBBF‰BLäAð‘àB_öàBwgƒBFüÙB}ýBGúB÷žBMwÍBDB3J½B*ÄÝB7ýïB ÚB6F~B*S¤BiUBß{BRB)§åB¥²B¦BÀ¾Aâ&íB­B ^£BÈÒAü‚ Aö8Aì±BîzB“e)Bš†–B©—ƒBŸ‡ÞBšïèB;[B êOAçŽõCÌOEL†`B]P·BgàBLeöBb+üB=¥ B!lB!;ýB<ÎB–B¬œBOÎB*8òB(»6B öBK B>›B+Bm!¿B±8³BöÖÅB÷V¨Bõ£BÞe“B¸ÑãB;Ç*B~ºB!t¸BBÏ)B‰¬°B™M¤Bˆ‹¿B£±?BnïIB2nÝAó¶}Aî|B/úB?ÀxB8 yAúETAå_XBJäBOÿBÔ*ZC½ÒC¡ÉCÛkCc+Bí/ŸB©‘B<®BÍ’B-è6BO¹âB|"B¬ÝQB˜¢|BqËùBŠ-ˆBeAhB%]­BßîAýÍ,B]›B 8_B¯«C®C ôBüͰBûÔ§BÄùæB>ÔåAàVâAÍ¢pBÔ)B› B¸B4P—Bˆ8“B\œéBŒªBŸdÅBi×qBœÖB½GB¦AÌU¿B<ÇBãáB5q BA{¼BM['BKêâBW}`B'ßüBŸXBÎB8êyBš†#B­ÆùBÁº+B¶ ÞB­üVB°öÕCÑC:†dC4,oC9}øC&žBĦB!êB#aBBB›`B'-#B(CüAÍÖ\B BžøB,P…B#?ÚBJ2€Bc.£BbÞBZUBB ÖAà1B<ŒGB›8üBÂR“BÚËñBÉÌB¯¯êBq»BU>B´BÂèB¾GöBÕ(2BçLåB¹YòB¾âÅB¬7tB£.õBŒþBM['B%GB"Aÿt@AñÌBöA÷ñ-A÷¸Bg—úBH øBN:*B9±BOB£rBO§ºB'ÊB[E.B`([B4ŸæBö¤B•îBïJAýC AäØBÈjBB#.qBîIAüqÝB‘rB OB ËÕB o¸B@bBxBAµBrƒB•O»B˜ÌBÔ;B˜Ü?B¦À÷B3 ¦AØOBŽC‰ÉûEÇBO“BhmBjÚ:BVøB28B@-B ©B'¼ŠBŠ7B! 4BSdA£akAúð¿BdnB(—ÅBS€[B6/BPá4BJ„]B&ð±AçëˆAò¡ÔB$-÷B`ùB°ºSB´f9B¼"‚B›vB®`âCÿ=C=dC-ûC("CC †êB¿ŸÆBù4BA³£BY BjAAüT„BðúAè·`B æÔBÓKBæAçbþA燈AôLÀB)ÃÅB †AÕpÆBü B ³•BIøðBL°!BNoBGÿ,BvÕBS­BÃRB=s-B„¹sB»ÂBÅüBÒ‘ÃBÂ*¼B“€!B‚ª BžieBµyµB±Þ¡BßKBù#LBÂÍBè+BÕ,Bá¢B°‘vB ã¹B ŽBÈhBAPœB‰MB‰xÖBœguB†HB\ŸðAûb;BðB+ø3BöB3ðBC·B ìB+|)B5ØBhB³PÔCªWC ýC¦CòSC2B@i×BI.B"¨B‰ÃBûqB…ÿåB—ÏûB›Ö¿B‰wdB‘]BKàrB b`BpöB{|Aÿ¢°BÊ"Bªf$C wC‹C=`C6£BØ‹BF’ÃB|¤AÑŽAÒâóBPsBó.BBø¥B0+B|à¦BuFBƒ6oBFì.B"AøªB ‡AôÓcAÑã.A»ÖöBèµBEãÂB?žõB-L•Bbw BCÀAì®ÇB¤9B)ŒB£¹BŸŒCB¯ažB¦ B®¢ÁBŸ ’C ÎCF0{C8‘xC1ïeC#B°ç…B$KÈBaÁBiÿBC’BÉ0AÞÒ¶B*سAûÂbAò,‹BûÕAÙš,AðÈÆAæ¡BC×B ÚAàµgAö íB êtBLÃ_BH°B_¦ïB/øBÅ]øB²xBȈ‹Bà¨BÖ+gB·d“BÔxNB­äB„BôÕB"5B –‘AúAÅAºô BÐÝAÔcA¼t§ByªËBV•BOOŸBþ®BB9*øB1ã¤B/ÔâBDIÅB%•¥BYº B÷_BÌ Aþ BVôB/(-B8]B{ AøuNAå™)BlBQtBŒÅB 8=A÷¤#BÇBPÔAüB;ývB—ÚÓBŠªÞB•xÅB±à8B¤|ÓBÄWB ®žCr…Dò6CeùBRCB‚œ@B[i¤B{uwB0ö\B Ÿ€AÖs Aõ„ÞB~AB&-ÊBÃB³ÖB$B&@B*jgBBÍB·ÎB*–¢BÊBƒBóÍBß–˜BãÑHBÛöBž¤¬B~&B%¥ABpkB/¢ðB—82B›!£BåBÞÓBo€åBð®B+°B/ B ë¤Aô\·BGWB »bB'¨£B (sB"^ËBÇ"CØB Þ B%°B)oB•B4k@B”ÄïB~çyB‹þÉB•CBrCçB?ÜB5™,BéžBáÍBFB´XBÐcB3TgBn4B3ÞBÜ£C C$r©CèÙCóºBÖ#BED³BçnBÛB9BGCGBrXB PB¡3žBœO²B•x¾BiqAB†žA÷”XAíÀ÷B/pB1‹­B£iöCq¦C6¿Büä£BþhCuzB ^ŸAÂjÃAéPnAÌç_AÁ:ëAûLCBBfBwå?BŒ…gB»ßB‡üXBYhuBbAÔ…B¹fA¶°ÙA×B¿PB*åB*ÕB:(zBdk®BV¨BÑAâ3HBÜõBNZ¨BŸ¥B„EcBª4æB²”*B»¼B•‹C)C/ßäC9ÿ;C$¸œCŽÝB¿¬Aã±ùAÄ×Aù~ºAàkƒB ùB#ÏAÅêêBÚÒAþïAþá’AìëAÕ A¾R±AÒ‹™A샨BRAÕ,­BUÏB8çSB=9BG|BKF2B#7jB„2Aÿ…B-QóB}¾BÐ@LBݬÔBÕÝPBà`§B¡ÜÙB°oB@4BªvÃBÁîqBâ,ÀBíûVBÓ¾‡BºBºAú˜}B)ï#BµÑBBõ[CØdBþº—BÚu B¡MYB›WB7ÎBV©BI=ŠBŒfB‰ôëB‚kBœ¾†B_¯®BGrãB+^B"ŠÕB±ØB#?šAÍ¿ÀB}B îB «ýB.¶BÏÎCm.Cå†CoCáBÔéB)öÔBN‚AïæBðôBB}©Bš€÷B èB’¡B8ÃBˆéBr7æB$¦BAí¶kB©ÇB"]¤B#–$B¤"ÓC¢Bþd C‹óB쎮BìîÖB:’¾AAë §AÙW Aò0’AÝX BG«žBqB‰ö\BƒÕ#BŽ BI2B PA͸Aû†óAÔs B 2Bu*B½B"áBJêcBƒ¦BJ%EBî‘AÝz©BSBI]EB•Ë3BŒÅB¤iB²asB¢êSB¡zŠC—4C/[C*ñ„C/“ÐC"EBÃtB"àiAÔ5—AììAþkUAÛ¼‚B±Bo2B‘AÍTAÕråAÚGnBÇäAÝ5mB,ŒB™B`tAÚÎ B+$ÀB:—BQïBFwBg<^B1¼?BÓWAè>lB,B“WQBçÐCBÖ!ÕBظTBÑ)B—EBgíJB®ÏþBºH Bã|BÓãËBBÚ±B¨nXBËÖ½B˜¬7BhiTB@õZB,±BÅ=Aå¨AòƒCAùöòAõ&BA¤‰ÆBo²¿Bm0ÙB@22B$iƒBßdB-2B,`mBLR$BHÏBãtBŠÜBÇoAõ%B®B¿üB+ÈÓAýZÆBµqB)¦àB+ÜB­Aüç£AëÔ5B0—ÙAáʳBùËBá+Aå¨äB1#ïB•3 B¤ªtB°×B  kB‹Ú›Bu_ÐBC´vC€nÏ•BB òõAܳBB—ÙBåXBšãB§ß/Bºx;B•_$B”}©C%ù9C8C9@NC/ßÕC,uBÏÄŸB MAæÀ.B &ØB õÏAÄùB åöB lB ×AøÞ¡AÂáƒAËw•BÝ€Aø—zBöjB9B AÞæ’B(â"BDêBTÑ8BNo’BUüBB•õB!&BóCB2;eBs6îB·OBÃÖMBåótBÔIÔB”c7B}ÎvBµ³B¿`zBÒÈABÆœeBõ…ûBÑíB«&›B«ƒàB‘®Bcè«BøiB=ºA÷ÅÝAÑl”AöÉñBJÐAØâ1Aë«ËBP ƒB‹dmBg|B. B.½wB4È(B2÷ÄB9² BDŸêB(føAüyvB#4)B+BžAÖœ¶BÉ`BƒvB/ÙxB®HB%\ÓAúoAçë B BñÿAÙ4­A¹haBR¶AÿðB BB’ÙB”jßB¨;±BŸ¯“B„ÌæBbözBÛþöD0‡ðD˜¼gBxÚB€´ÔBSª$B_cBdÔ]BUB‰nBÆB²BFÃBߦBó8B?ã¨B3!RB ”B}öBFBB4.ŒB¼p"BòþìBýÌMBÙBBæMjBÊEóBŒþAÙt“Aî­AB%ÔBjöŽBŒ¼ B‡¾¾B…+œBŠ#>B4×ÇBpóBDéB)Aî×BéB)jÉB(Ë,Aå àBïBËŸ%C üàCJCYACáfBÖh1B\ABß8B18B'B/n4B‹ž’B¤ãMB¯¦B†2˜B„«?Be£AüY?B1«HB)@zB îºAîd-B¦’CÙ²Cþ°C4©C%0BÅ“B [ØA÷uSAÛ@0Bú‰BõmBêÙBgJ,BÁBesB….BsVÇBkÂfB2rB³¯AÏmB ÖìB"ÙB B1ÿåB=â2BIB=f(BDÈŠB5 ªAÛÁ AÆÇÑBI\§BœÀB´JB¨—ÜBº/±B¨&áB¯Cê$C1:ùC8éŽC0ä­C(bB¾FSB1ýùBžÙBþAôÊ¢B ”B<0Bž‘BÝBŒAíÌABQ²AíÎ-Bk¨B#BAíƒ-Aà•‘BJB®C ÒËBéA±Bí܉BõùîBµ0áB yA¿1¢Aö]B ~ÉBvËsBžA¾BFçB~­Bs‡B@èJBÝäB*˜ÄB'K”BeéB)ÜNB3 jB7÷ÕBbBE\B»ãLCdÉC %CÖ9CÆWBÐÏ B}ÜB¤—BíoAÔIJB*öBVB¢ _B¥2©Bx<®B…ªBWÅ)B#PYBÚÝB/ŸB‹BaBõLC Ñ×BãÖ1C ´ÁCÁoB·HtB%;²B˜AÚ:ÄB]æAÝîØB ¼ŽBfXBŸ@BG"B†Bg¯0BV[ŸB ]˜AùtúAé‹éB|TBPB«BZ—FB@‘ÀBF®,BLjpB6àB­>Aí¾èAüKæB0‰ëB‹ª#B°·±B¢6ŠB ÐÖBGóB…N6Bt3åBÆôB©„aB½FŠBž7CärC"JðC-¶C:}¢C€BÁºB'`¤AãœB'¤B=BxAņ™AüÝÞAí?ÎB)ºB•OB)GAÔ2\B ¦B ´B—‰Aá!ãB VPB&‡UBf²6BFîBC8B`·BE9÷AÅ¥^B=4BIÐ÷B‡’BªCºBʤ¦BÜj¢BÝæqBDtBzÏ=B§ŸIB³ BÈþ BÆPzBÞ”B»þ-B¬>B¦ÈbB¼[qB€wÁB±ºAø°¤AõKjAþî·AådEAúÜiBo0AºM‡BUj³Ba•2BHå Aó0hAú#LB$)B'Ò‡BMÞJBC§¯BR¢Aú®BÕïB$BØ8AìA[B nAøÕeAç÷³BéAûŸAB$ÃAßs¾AØÔB¢ÛBlBNyAÿ}rB+IBP‘BŽ(0B ´6BÜ[B§ÁWB³¦ B^o¤C€‘ìDäb¸B?µQBRÛ:BYCBnÒÓBYœBIuwB5F+B‡’AóWB>AÌ™ÔB ý3B PcAüöB¶/BßQB)(ABÛBž3B-2ÞB®ïÍBôhCÏÉBé+ïBøŸ6B³‚óAû³}AßûZBò:B'i$B‡g'B~¸ B‡8 B”:QBo¾fB3‘¢BxAþyB‹B9hÒB$âBÛB ¦`BB8ìB¿C»óC ?eC£ìCâLBÆ_MB›ºAêú»AÅüB¹B®:BÍüB–¢.BšS_B ú@B›tPB[ÂBü3Bw>AüÌAÈ^B8§B£ÞC{©Bî\ÇBþxSBýëðBàÚ!BÖxAßnAÖûƒAÂ2_AôáWB„½B*„UBº²B}öÇBv ÒBBUœBq4A¸ÒaAæ?2B„AÕì\B$ÇB^0BNÛ1B[öôBGM‹BG-ÐB ΕBÿŒAÀñ8BžØB™aB£ÉB¤žñBµÑÑBÈ!B•å¸C|£C/¦]C)½%C4†2C+©6BׯB&XBË[BìAò¿/AÉS^A¬ŽAņKAÑ«Aí"§B8GBâøBs“Aß½AîkBZeAèi B HB jYB=ûBWË¥B]ù_BFÒwB:ÓRAÍÚûBŠ4B*„TBŽ?B».hBÞwBÓÙKBÉúB†€B€]BxöBCoB­…WBꆜBê‡Bß)Bä–çB›LB )Aê{ùB±B%œB‰”Bƒ2FBŠÂSBbM&BZØBKoQAðäZAÌîœB¬vB #¾B0e8B GDB gHAè9!B ÑQBÈ]pCˆZBýL^C­wC0qBßœÝB  Aý ãAðíøBFBãíBdz×Bi«B‰ÅB“›µBœßUB\Õ&BvBG?AßÞ¬AÚ‡^BæPB¨®âCbiBöòäCC°B×u_B(/B íAæ5¿AÅ(:AÁ@;B`„BEƒïB~pB‰`Be®‡Bqì-BG¾Bc=AÒ}®AºÀÆB gHA¿eÆAØN$Aï oB §´AÀÎÅBÊAßûB žÑAéåúAÈØBMIAüƒYAíÆGB"ʉBXp'BICŒB[ëB=“?BFÁ>AôGAÌNÿB2ŽB—R/BЋªB×GBÊ»5BÌ­ÄB„?üBb?°BãéBºÒ$BÇå@B³ñBä|uBʳB«ŸIBªábB¦æ(Bmy·B8XÊAõð©A»TÚAÒ)AöÙZA×5_Aóú½Aõ2FXTENSION= 'IMAGE ' / Image extension BITPIX = -32 / array data type NAXIS = 2 / number of array dimensions NAXIS1 = 200 NAXIS2 = 150 PCOUNT = 0 / number of parameters GCOUNT = 1 / number of groups EXTNAME = 'VAR ' / extension name END B²ƒ˜BÓÄ+BÈ:cBßBŒÛžB–#ÊB§vB¡ÄB£ž—B«°B’áBŒÆB‚îjB?hB˜@ñB©ðÄB‡¼zB‘êrB~äB‚$ìBŽÖ:B\cB†‰ìB‰ÃB–ëØBƒ´ŒBˆç\B²"B––BÁ»˜BÖô7Bî3tBäLCBìaBÒ (B®ÂB±B›#vB£œ5B¥UB RÝB¼¿IBÃóB²ÖÁBŒOÍB’Ÿ©B—ý±BŒŒBÞ$B†BÄBx‡FBŸ BŒV‡B‚þ:BzÌ B–ž@B“ÜBÔÉ™C$ß­CÆC$ëïC-ðWCŸMB©\RB”¥rB„]«Bšã…Bª'®BË~GBºrXBÄE>BÖc6B¼1Bž¼B‚£ØBt…PB„P°B…\Bƒ\ðB•2B‚æ«BŽ –BÌ#.C)C;C0¼¯C:}C@H¹C(_–BÅs*B®HiB™9B‡TRB‘'8B¡0B×ÓBÙBNBÏìãBÐAB¹öÊB™Ñ|B›ÆìBmÚ–B}çB¡÷ Bª„xC-îkC5–ƒCA7/C%âTCw+BÎ2B„B³uB‰õeB’ö®B†hCB˜×÷Bº|qB³ÐFB±ÔB¼£gB½±˜B°êrBŽÎ½B‰G×BŒž)B”ÆBŠ:%Bª¬`B¨»¾B¢à:BšB©ä`B¬uB˜÷B…‰BžfB³‡­BùkðC«nBØ"SBãÑBàøVC½œCNJÆCSEˆCF ÿC3ûtC&Ô'B²ñ­BxÁíB†cuB‹C‡B„޵B…?¡B^ÊB€{BuzBvÖ”BŠ3æB‡˜—Bzš B}_¦B]^gB‡ÈªB„ž“B›ÜŽBœãB´šB ÐÓB±¤B±}B ¦ÿB€YÉB‘@³B¸4ÊCtäC .CLñCCùBþ BÛ¹ŽBÔ;ÅCü®CåCŠÃCÍ C |iC.«BéÓ¤Bæ.BªŽ‘B šB–-FBFÎB„ B²BRtBŽ 8B‡ïB²*!BÇ [BÇT[BŒÈ2B‹<ãB˜B”iŒB`ABB…Ä…BÄ*„BÔ*©Bº\mBÄŠ1BÊð*B¯VRB–¥BŽžbBsQBgBlXrB‚¾Bž;÷BÙÃB‡y‰BϯC0>•C-ªºC1æC5›jC#ÆÄBª¹ŽB’ƒB–Ù–BŽ’BŒaB¢»BËUœBÈ^õBÚŠcB߇ÊBËÄ/B™jÌB¦?gBƒEB’bÌB£K£B¿IC2-ÆC8-YC4(CC$Ÿ—C¬¤B¯àMB“ZàB‘‹åB{ú[B‹+5B€cBk BÀ®±BÌ’êBÅòIBǘfBÉ^ºB±þ B–0ÖBŽ…ÜBŽÁôB‹eÝB©5B” ÖB°‹tB¦ÉÝB£È£B§‰B«GÜB©†ÓB‡NBŽB³zjBߺÀCÎBöôãBãÉ5Bæ C H]CS!CWøECaá†CI¦jCJB´½}BgÜ^BuUfBƒö€BqBs9úBwA´B–wBŠ2,B|ýB•ÃBŒQpBa®¤B‘ƒ¹B‰E¢BpÇB†?B™ê®B©µuBžŠUBlÁB¨®õB¦!˜B¥Y˜BŽû*B„ìB²8LBñÈÛC¢ ChxC νBåˆÎB±¼CBÚŒÊBþ)C ”ˆBô>-CÌhCýÇCÖXBág˜BâÄ¢BÇaB›²sBªåB‹aˆBƒ B›CdB„ÜOB‹"BŠpBÃRB°ÿ(BÁžB‘A»BöäBHºB°×ÑB¯?B± Béº!BЦB§ €B¦hBŒ6B‰I¼Bt Bˆ#B•œˆBoSsB¶ DB½È›B¥ˆ>B›øBŠ¿CB„¾*Bˆ±vB¦á.B²<èB ‹¥B”w±B”ã£BˆµMB—áÉB™ÐâB‚ß`BrôØB„r]B€sB‹~®B” óB“3ÞB<×Bxå¡BÁsB^ŸBŽ}PBj±,B‰^,Bµ<úBßà˜Bã.ÄBÞ*^BØ‹èBÄÕÅBŠ ]Bˆ] BŸâ©B¯Ž«B¼B•BÅýqB¸—)B¿'íB ËB•TCBƒ˜ÚBšÆ}B„UBŒkBbXB‹|B™¤BŒ B’âMBù—BœÙABºÜBÞ¾ìC"ÎC3hC-ÞCøGC ß›B­ÄúB‡ãâB’’úBr UB¼ UBÔÉåBà}Bç¿?BÒô.B± B§›B’ªˆB™ôB…ž£Bœ3ßBe)BŒºXBŽvB˜¼ÛBÙf.C0îZC(ÏEC,¢[C'Ã|C% !BÛ"iB™¨êBƒ¸•B„mBЏâBº1½BØZBÝRüBÛï7BöÅdBµ/B‰OÔBÙ\BŽ­ÜB€ÆAB^IB²cªC"ÀC3ôcC˜ÝC/áØC_âBÀX¼B„ù¼BjR_Baœ’B}¿pB…®B« kBÉ~ŽBÔ‰ôBƹlBÍõBѽ B“/B†éãB€Ø†B‹tÝBmn†B„'(B‡ÙB¦6B™ëBB¯ úB¼3B¬ËðB“ °BcÉMB€6Bà~…BøÂ†Bõ;¤Bá,BØ:.BÌáaC©hCTCcyûCFrC@&BC%G0B´ïB…¦ÏB•Ô&BŠBe~ÌBÀ¼B†'¨BœZUB…{ŠB‘9ÉBœbBq\JB’žƒBu7ËB—¦Bx…ñB·šBy­"B°î—B²„×BɲõB·½ÛB¬Ð¿B‹Ò"BqùB“æáBÌw!Bí*C† Cû BôË$Bú·BÓ›BÜ‘·Bé\µBùÖBøý.C¿©CkBð/VBàŒñBÝíÊBÖV‡B°(ƒBÀüB{`µB‰AgB‡*ÊB—BŸºFB×ùB±AhB¾n|B¹Å]B—B‘!(BŽAB–GB£5?B¡ù“B§þB’B“&ÍB‡¯ºBŠQBˆ}B‹ìèB‹äÀB} yBŒ‘uB†E B‹`WB•µB™ŽB“$fB…î°Bc–¶B‰‰BÖ BÚÖ€BÞIˆBùÛ5BÆ?´B”}ÁBˆe!BŒ/QB¶;¶B¸n6Bº4BŸ•¦B³–OB”j†B“dB›\âBœ£ÎB„'Bˆ!B«ŸB£×B”&¼Bž ÝB¤¨¯B‘)ÕBƒ ðB|ÄNB®dCjÝC"‡ÈC#òGC,C´íB«^óB’B’$BìBš ÞBÆEôBΉUBÔãB¿ákB¶6çBuKBÄŸBƒÙ0Bw\¨B„ÿkB‰9BËB&sB…̵B×PìC<mCGè¿C/•×C9‡C,cUBœÜB#ÐB’•BŠ“ÇBŽL.B© ÖBÐ…Bëõ†Bï_ŽBÌÚBÒBþ0B—gB#BiùB‹ŠåBȈQCÃ^C,e½C*øZC0óÖC&GàB½rÓB‡®oBƒëuB|B„˜‰B‡ÚªB˜¥6BƈLBÄB¹ZEBÅ×ÛBËËBF.B‡ˆtB‡ÜBŠ`VB†_ÒB‡ºtB£-×B§3¥B£}¦B¯}FB¯‰KBœš¬BŒëÇBŠà´B•PBáBí²Bá%¾Bú^ðBýðBóqÝCt=CH,CFgiC>®~CLÕC$RoB¨½eB„Ô&B{1B–7BˆÃÖB¡âB{eXBšæB¸BƒFŽBuÕOBˆ7tB‚ÂWBÚBz†EB†ëBŽýB–üB¤¾Bª¸BG¿B­¬_B¦Á9B—nB}é’B—y²B´Bð:OC ×áCAyCbÅBåEýB²l·B×DçBæÙ[C£ÅBõJuCEÁC¹ÁCZˆC ì‹CSÔBà½åB 3WBˆ6~BŠGÑBrrBn°xB„È!B‚b«Bl›ÇBâ*B¦¾nB¬ •BªÓOB¡ô¯B£,ÿB¡*;B¨1ÀB¦ƒlBµm´B¯aB’2 BŽ­B‡TB®t“Bí.B}ßjB‹/ËBm~tB”íBŠúB•ÅÞBˆWB‰îØB“°dB”ÂTBˆ&BŠ —Bš¯ÂBÈûÕBÒ!ñC™þBâhBü&ÚBÉ€ŠB”NNBŒ*B•yÓBÏgB­`B¶ˆB®RÝB²°¦B—]zB–i?Bƒ3óB”80BKB—`\B‘qB¡B•nÄB•ÿB›àÃBçÝB‚7BŽS‰BÇC"qC%t§C.XCÖeC–€B¥÷B“êÈBÙ°BŽlŠB±`BÌBØo BÇtB¿(óB½³BõB—EpB{B}"B„q½BˆíUB€òBúžB‘EbBÒC6!dCDŸzC8®CH¿÷C4-¢B¥0hB…ºB…3B–¸’B•0Bž*VBÅ`JBÜÏËBÎÏ«BÖ¹%BÒª5B…ËBˆt¨B–”ƒBoÓ%B‡ÆŸBÆ™C&!?C-”±C&GC)×¹CýBº¹`Bn jB{í6Br°ÌB GB…B“t B«ÝŠBÅ ÔBÕ*—BÈДBÅDhBŽT€B”-œB™.aBŠü»BˆUäBB§”mB®º:BªB°ðB±„+B”+°B‰·AB†B”JñB»pŒBâªYBåBþ/ Býd(Bê†ØCù>CSÊfCRà¿CF´hCK5JC!'sBžYîB†ÑnBŒG€B޲@BˆŸíB…ÒŸB„|ËBˆ¡^B”%pBˆü·B€FoBƒaŸB{­B”"B’þ?B‹7ÞBzÑBtÕÕBœ³VB°{¿B¥SB©ÅB·7ÈB; B‡¼B޲@BÅ07Bó’9CŠCC ›ÕBñ½yB¾Z³BÚ?ŒBìÉ5CнBÿóìCÜ Cæ1BåmBó@ùBôi›BéùB¶™!BŽÆqBš B„¨ŒBxz†BˆHnBwQhB…L}B°5C%€”C>)CÜB.·B•øB»êB¨ÅˆBÆCþB׈,BÎÏ}BÃæµBÁÞ B³BŸB„êµBÁ”Br?ïBŒ®¯Bƒ/BñB†åpB‰F“B‹°\BÕJ#C.¯‰CAsœC3r†CCë”C'ÃlB¸}B‡@NBãEBšRüB‚ùB•[ZBºeBÎr8BÎésBåvƒBÚ¡ìB“J‚B}ÕPB€ë£B`ÛB…‡ìB½` C æC'BVC gÆC&.ÜC¬BºNòB|úB]ßšBÏ B  Bv¼øBšCBºcBÏ"©BàcõBÔy÷Bº€ñBŒïB“XsBŽ^jBw*Bus*B…š¬BêBŸdB”N B ÅvB«eB–Å_BgÜSB¢oB¡?“BÈUÍBÛ™ÿBðKBüN“C£ÕBÇÆˆCÜCX¨³CLZCZ4ÚCDíC.ýB—‚BxnŸBeTB{´B‹Î+B‰eWBx§ZBy¼B&åB!`ByúÆBd´¢B‰ìëB†»œB‰SBtGBýÌB…)5B”_éB¦KâBµrBª­ƒB­r*Bˆ¢¢BULB“iÂBп)Bôù¨C `C ]ùC(OBßòBÍ BÛ7qBôãŠCÐÎCÄC[C6aBÖÑ|BèexBè% B对B¥ì°BäìBqkoB…BhpgBœ4Bƒ@EB†qB£PñB¤gB°X™B•ÏmBŽ·B›íÊB“ʽB¯PCB£}ŽBk¯B}]ÏB^¨¹B{3B’ŸbB|¬MBzȸB‰k\B€ÄÜB‡TìB“ B—%|Bˆ‹B‹>¡Bš7ÈBˆµB‰,ýBXçB{ÑŠBä‚BÄLoBÒBÌIBã#9BäQŸB¾ùBŠŠ‚Bއ-B¨ÅéBµNBÇQBÁ1VBÖ)˜B¸†B±©ÞB‚¿Bñ2B™UÿB¢É9B¥¥B—ÆBˆ£}B˜ûB‹ ‚B‹=ZBŽRÆB–OöB“ÕYBÛAêCŠ;CuC0C"îÖC×ýB¡NaB„‰~B³ B³-BÁBŽD|B‘ZcBä€ÞC 1´C ­C`ËC"é`C B™ÏÄBaTFBˆ ÚBy{éB§È®Bß5–BÚ£eBÀÌ‚BÃcB­cJBž’BxúBšˆÜB†|.B‘• B¢/ýBˆñ‚B‡Å‚B‰YÕBÚÄ‘C4&XC(ñšCEõòC* >C'R³Bºâ’B`šB“ŠB’¿B†r‘B­Z(BåžíBß™–BΩBßlàBÛ QBˆ%.B€ BÉçB‡‡BxÏÌB¯µ…CP’C#X¬CûÕC&øC$ºGBº†CB„~B‚U¯BƒÃŒB}BŒ˜™B‘¢B¯ÇÉB³ŽB¯Ù“BâQABÈ‘íB¨¾ÔB‚ØïB†ÏZB‘¦YBqÒaBžVjB˜-Bª¢öBŠâŸB™‹úB®Ï;B»/ùBwG}BŠˆ=BŽrBº-RBÙÿïBæK BßÜäC6Bèª@CglCG=ZCP5€CJ>CRöC"ç±B²]B“§BxÚ`B‘šB™4zB€HBƒÝ‚B›¼B€b¥BšxþB†ÜÐB‚ŽjB[&ŒBj±BQ†!BnlBwx‡B…kB¦[ÆB¢™ÂB•bB¹²>B¶rÿBŒjrBUÖïB‡šBÄkèBØþ¹CµlCذCâáBÜÚ³BÔïÈB臣Bý)[BðœaC™…C ëÔBñî\BîüÿBýqóC)DBÅ^7Bà BtÀB~ÄÌB‚ÊýB‡a‚B„7jBOBp4ëB»¸7B±ÛÍB­¾ÃB¤˜§BydÚB‚ãB§Õ§B®}B¢"BžB˜b)B†…¹Bv²B”ݯBq=÷Bs¶DBtIBŒqB¨ôBy­ÅBAqBíÞB{äÔB}Õ×BƒéëB†šZBŽFçBÛB–¿ÓB¿sÝBâ6£BþBÑ´sBÚIB¸\B‰_«Bƒ ìB‘ 4Bœ€ÆB£:gB·}äB˜€¼BÄàÎBêoBrêRB&B…þÅBgÚ™BoãSBoŸBŠÐæBc’BеB”ÞïB…+¶B„üB’ƒB×çòCÄCsHC \ C%óBÿSB¨BzB˜ñ·B„ÞNBÄC˜BÚÕñBίÛBÕ ³BÒVóBºèB’nåBãTB„ÊB‚â#B„žBCWBoÒB{=B‰ÍÄBÆu!C(…9C'”ÖCDC&”C÷ŽB»aBŠbSB{BÛB?HBdãB¡hBÌ÷yBíP8BÆœBÈò&BÁXBˆ^ñB€$²B†î¬BnJ¬B`T¤BªÆ!C"CL—C×HC"–zCêOB©·ðBŠØB‡BHBhhB[Ú~B‡‰zBÕ¤BºO†B¶—šBÐî`BÀÿBˆ ÎB™"ÁBŒ€¡ByæBvtB)ÜB“›ÛBªËkB„ÒJB“£B™!ËB®B“ïB‹ÕõB‘{¡BÄBÚÝ(Bì®®BÜÊCæ8Bß„CÉRCCôCOÍCOMRCCýåCB©ãBŒwúBn¦ûBeªBÀÒBt]zBƒ™OBx‘pB‡SB†ÙÿBxp¾Bi`BhdBžBs®zBq͵Bmó,B—·ÆB™+iB¡ÃgB˜¨)B¸åüB¦½pB€ÕžBn‘ÓB{x´BÇ\ÜBÝs,CdBz¨NB—Ü^B¼v?BЛBÃtzBÖæ\BÁÂB±äÔBŠ¥½B„¦*B„@>B”÷B¬iòB¦ 8B™âB±~èB…%’B†ÆàB’ qBŽGŒB’F#Bk¨ÚB³\B‚/B†¯QB‹šsBV²BƒÀ×B„çB•ãBÉñC¸ CC}C ¯CIíCŽëB‘{¼BŒ˜KB…ù–B‚~>BµÓBâ­½BØÐDBÊBËBºµB™ÀŽBˆ¾=B{͇B\„æB‹^ÕBvœ°B}Â~B^ð B†oBŽ—ÕBÊPAC"Ü>C*G„C?AtC#áC"åB§õ‘B•›€BˆúÑB‘ÞBc# B›…ìBËæBÚFÈBÞØ}B»Æ¡B¿7eBu:B~ÔˆB…ˆ BqúB‚.ëB°ÆC&IC™–C'(=C"~C&þ,B§¸Bv·B†ßàB†¯QBy29BR$,B‡ÏLBÒ]BÏ;bBË‚üB¿þB´xqBˆënB’¾TB€ÛùBN8UB€HÜBˆcÛB–í{Bª+éB‘ FB†ŠÈB|ÍLB˜]DBxÕB„~CB…±yBÄíiBÛBàŸÇBåÚ=C¿ÛBÕÀœC3½CI¹CI÷FCDË=C:y-C€ÞB «B‰„ÌBw=DBvÌÄB†¢ÑBŠVäBˆìeBŽ#÷BŒÐBS=çB}/B|?ôBp1lB‰ŽiBdoB€™&B_îïBÜõB‰”ªB¦B–PEB¢YƒB †°BŠ«Bg;3Bw%:BÈ îBÚ@ CªÝC¬ÔC’qBáò¸B´å“BÎ%BÜÞ¹C ºBø‘C2:C ?Bü:Bå!ŸBéN^BË\†B¥À/B…ê¯Bˆ™8Bxk0BuÃaBxÏ0BtsÎBplB±wHB¹B¡ÕBB®µBíæB˜å×BîéB¨†B•vwBŠBB—ÒwB~xB™ºØB›rÅB‰¿—B‚šÎB‡_FB“¬B0B{ã]B‚õB„›,B=B…9}B7öB’lÍBƒ¹±B€nÈB‰Õ¨B¨¼¢Bß°BÚ÷.BÜrøBÔÞ—Bº'ªBpz`B±ÀB޾;B¥þŸB¤.­B³aB ÀQBªáB–7°BB„õéB€O Bˆ•ËB‰ÃDBq(ðB©)ðB´›½BÎEêB¶úwBÀS?Bwø4B‚KBŠU¦BiŒÝB…B]gBB“âÖB–ßBªu«B³óB¤É¿B¢Bˆ¾pB‚ÀB€ZÙBÕZBæ™MBãÚæBôT2Bç›ôBÌñ C­`C`½ãCJËdCLÁCGIQC{¥B7JB~n Bu=*B€/Bެ´Bú¶BhÝB‡;lB€×^ByŠB€¨»BwªQB‰ì×B•Q.B{£ŸBt©Bv<ïB‰mëB„íB¼'vB·4¤BÀ[çB©œ\B’~Bb;ËB“OB¼„»BýïÎCy¼CP+C©ÞBéÑVB¿ßbBز¨Bê3jB÷CHüCBþá&BèIþBé(–Bä^&BôçËB”hBŸ BY1`BUïB‡DŽB†¹BrBef^Bª{ÐB›~Bªõ«BIóB4.B~“BŒPåB“µ|B€uB•ÌáB5ÍBq7ÐBƒKhB‚,…BˆŽ‡BÞ}BŒm3B{ø•B†N[B†‹BnbqBkÈŽB„ÐöB{¬ÈB‚ëuB~…þBŠIÐBs#BŒ4B°õTBÞܨBØÁB’sBu¶Bc™ÙBNÝöBoë°B‰CÍB}ÞçB„ WB‹ BVÒõBaò·B}ìUB¯¥oBÌs”BÕßíBݪ)BÓˆjB«¾bB‘Ú„By;ûB†T B ŸB²ŠHB¸‹ÇBÉÎ B·J B‹-cB„5B|MBz»¢B«vEBˆ·B±‚B W¤B›ÝùBŒê”BŠtJB‡J2BŒØB˜î BÔ¨àC¨¬C§C¦UC§ÁC[B©#Bz>¢B„z÷B•Ï~BÔijBÇs¢BµhåBËw„BÇÕ¶B«uNB‘!æBktB— ÍBs¥8B‡jãB|ÓBƒm¼Bp¤óBa˜B½`QC'ÖC6ëC2HXC(«ˆC¶½B²XHBkü¥BébBpÏABTKGB¥8­BïÁeBÆ|…BÐ’B¸ëtB·,VBá;B‡ä†B†ÉZB_ælB‹tŠB¬w{C JáC$}C,ª Cn C]B¨çñB„i©Bh}uB]éÅB{¹{Bj¤jB“Ù’BѦ4B°EÿBÄTBÈfçB¼íäB¼ñB3qBv¾|Bn}B^t;B†÷üB…ƒßBŽ3lB¤PwB¸ó B‘cÅB£(ËByç#B^¼XB“ÜðBÀ=BÖÚåBÙµ©BñVBô¬‡BìÕRCé-Ck 'CmËgCRúƒCZg;C$-B,¶BŽÒB‚´¤BsØ-BuYÂBpÖóB—äªBƒ<8B€4BB”aBµvB€)¯B|ÂÝBb¬ Br(sBYë¨Bk,ôB“yæB·…ÃB¢XŸB¢jäB­è¶Bª‹,B‡«ËBòiB†ó¨BÁþ C ù%C7C UíC=BBÜ®Bµ.¹BÊ„ºBý&·BÿoÏC ˆoC—C½BBîÚ&Bö¢ïBïˆB¾hBBúÖBÆŽBƒ‚iBO&ïBwüÀBƒšBu>ÕBƒ[xBµ‡žB°AžB§qbB•ìB† úB–¢B™½B†ô‹B£¶±B¡ˆEB‹ssBµB|J‡Bt‰BŠBQFB‘gBMoB}‡*B„[žBm…0B„¤B|¤¹B‡¹¸BŒŒB€·ôB‹ÝxBf9Bu ÍB²ö_BÊŒmBÔ„BÂ5åBÓeâB·ÎpBƒ”GBtœ~BŠëB¤7ŒB¢sBº<BºgÒBÇš¨BA7BsXtB€>oB€(RB•»ÝBŠCÐB…gB~ôBŽ/-B™äÃB‘~JB‘LÅBŽÕ BÛOBå÷·C§CnCáÁCóCˆB—€DB}*ßB:wB…ÃiBįBȰB¸«—B½uB¢®B¨áKB‰ñBkNÄB4Bˆ”B8ŠBoIÿBdmB\8GB‘é€B¼øC#%eCIzC9RC$çdCl|B«(B`J•BƒÀB—“B‚n‡B˜ú¡Bã.ABÃHiBã¬7BÄŽ_BÀóB†Ó BaiBqÖáBuˆBrÈ:B°<ñC`œC"*1C%­óCúC‡ÕB¥[ÚB„(ÖB~.Bg6²B„¹ŒBoZWB•ÆpBÍ2ÝBÇÒmBÁönBÄôKBÆm³BŽcB`ûBy}‡B€”ùBIšèBƒýBÉ%B”ŽB“€¶B´ÝŽB…ÞÑB ãBŒ™hBqÀÄB”ù¡BÈÂÏBâzrBÖÍþBñü¡Bæ'ÊBà1ÕCì‰C^6‚CXB Bg‹ÌB0Bt¸ÜBX B†ï,B„;YBnp6BtyfBYWDBd¶ÌBy@zBkhBfÀéBp ÊBZ±Bu©?B•W B¡éãB „­BªñæB¤±çBšk$B…­ŠBkç-B…]»B¹1øCæ¸C‚}C[ðC ”ÒBëò¹BÁ-;B¶œéBúÎCoÄBè6ôC¼£CkrBóYnBö[ŸBÙçBÚ)ÙB´BŽˆ\B‰¢„BoïÝB tBƒ½ÞBˆÆÎBnÃÞBži¿B¶kDB±zByÑÄBŒ+B„ªŒB—µB°–BšÊâB–ÛkB…™ðB}aB†Ë‰BŽ«kBqVrBŠ›BuÿB޳’B`¿ÁBP¢êBn B~VéBp0ØBq/B…#ëB}q˜B}ƒÓBo.½BˆÝ,B½Ç9BããÆB挅BÏ—†BÆ2>B³Ì)BwýC#y(C'6^CݺB®›`B…æºB[•BB…aBxгB\ÌËBp»«B´ ·BÕq-BÂPŽB¼QvB«ÇVB™œßB‰EµBˆaÒB…” B[­LBkcfBytBªb›BŽ™*B•›ßByQ¼BiVBzuB‚4“B*ÖB¬BÔ«Bä˜Bæq’B鎮BÒ Cº­CDðqCQšC=x«CSóñCMñBÑŠBèFBv³BV½ÖB‚lB…¯pBw`ŸBjŽBw·)BiÓBUà¯BÞ Bt`[Bn\ðBW àB,¢BZ¥ÖB}dBŸÌ B”Q•Bž³ÀBƒ®ñBŒÀ’BxçB†B{,½B½‘§Bå;ôBölèCPC †çBÙM(B¿ŸBË<3BõU”C ö3C Ä©CgC$(BÜõ6BÈëåBãeÃBÙY¨B‘7[Bô¾B„„âBmk—B‚ÙBuXnByýÚBm•æBÁ)FB°©œBœ6*B€,éBŒ#*B|ÿ-B‡’üBƒÂµB€}ŽB~mB€eBJº…BgjqB´ëZB΄BÐíGBÒsBíe¢BÎ[BãBˆ® BŽ'÷B²ÐB¤È½B¸%uB£¥àBµ{ºB”qB-BƒzRB‡p½B‚ÓB‰Bmò»B„=BfÉBxi’BfÍäB•ΞBƒ;ÒBSòBË™C§¡C2BCÛICa¤BöU BãBeÙ¨BpÏkB€Ã!BªZ²BËôBѬŠBÆ»•BÇøhB¯¢BŒìB|BâB†¹‘B›"B¦)B‡}B“ä¶Bv•MBí§C!ÈC5rC)û&C+ÖÞC¤jB£9BsZaBDE‡B‡Ê¤Bg‚©B &BÜ^ƒBÐ5BÍõB¼Ë×Bª7B’¬±B‰ ÂB>ñBz3CB›;B£pC"$ªC(+C»™C!! C*×BÂcBOòñBkAOBP¬B€D¯Bh‹BÇÐBªmrB¬Ë²BÄn)B¼òMB¤§B†:¥BWBr BN+-B†ŒBvg&B˜B~r_Bh×B§óñBÓy BÇ`BÌ»BäɲBÔà'Bz}Bv2B´|B¾HB² bB¶GzBœÚ\BžB޶¨BŒ$÷B~usBoÚ BT¤«B‰²BƒæáB•@±BƒÊB‚GùB`<ïB3¤B†"‚BŒiBÚ³ùBÖjaB¹`¾B½ˆ4B¤;ÇB‚FˆB…Ÿ¾Bƒö¾B'þBŒE¨B‚êôBp‚NB‡( B|•¤BÜ eC%±ýCBÏÑC3¤,C%áÓCË•B»ŽëBjÔvBh¯mBŽ{ BvkB¡$oBÜ’ÑB¼~WBÐgBÆÕsB·IB›`zB‚ ÍB{%BŒ­B•¯DBº—ÍC$WÖC$˜½CâòCM˜CåB¿ß¸B€ÛBu ÃBJHÁBpükBdxB–ÝB¡”ïBœçWB£H‚BÐlºB¸!B™-BZlyBo XBD,UB‰ðŒB€øáBŽ^B’–{B¢7B¦îB DàB\+B…{¯Bˆ*B‰5‡B·Ö„BØ7pBÛ'[BÜnGBßF¥BÞtC²CCP‹¬CHÆCN„ìCDQ'C‘4B™‘úBOâBc^ÚBn'Bg‚wBrXB}VBzgôBzB÷B†$oBZ BiyYBn¤lB|èVBfÕcB€h*BÇB¼ÀUBÉ€¾Bïâ®BøT²Bá¦ðB×KC!CLrðCRSCCP.wCAOüC*4`B¤-{Btô BlÉ­Ba8BgaB]×¹B}¡4BktTB|h³Bk®BuP]B`°‘BtŸpB^ê¸Bi°hBj ÊBu½ùBbiB úAB•Û$B A¢B‹Bœr)Be¶#B]éBtjŽB¾ÕBìJ~C#C á¬BöôÅBá[ñBÁ:öB»–ACéDBçb¹B÷ rCIC »-BìÈBí [Bâ`ÿBØn^BŒ¼BuÓ!Bwù"B~ÕÜBeWéB_…‡BnmÝBcцB®Ý C ñBŸê×B Bˆ`jB„pB¬¡)B¹ BÁu\B¦(ëB®RUB©‘B˜sOB‡tB}Ê BfcªB]ã¶B]O¢BmñPBˆ×*B… !B„ƒC(-C<ãC9“C)׳C(&IB¬,ÐB[æBwáŠBw3€Bƒ\ÄB³ãBÊWßBÜ:9B㙹BÕÚûBÉÑBB‰óÈBŠ×/BjçnBr B:ÝB¨¯ŒCýC«•C&C[CV=CMB¯ŠZB†ƒB€áBXÿÊBV™^B~`ÿB†VÈB´ÆBÍËB»AbB¿¼~B²î#B…tWBˆ”VB˜ÊÏBræŠB8xãBl¤ BŒÁ‘B“EYB™ÏbB©ËB†¦BšÆûBb®¡Bk B–âYB¿ùŽBÃdBìvòBåñ¹BÓÐÞBí¿OC²wCKÉCRÓûCQñCD×ñCâ¨B¢`¦Bi:–B\Ž]BRšBpÕ³Bj¯©Bg|oBbÚÜBvߨB]½?BsݨBX>†BPÚ8B^…?BL}àB`c!B]1ÓBj%4B¡*BŒÜ}BŸEðB¨ B¢›MBXøBGãB€A“B³«Bç×LBø'?C87CNÛBÌëB¿ËáB¾ÏõBóܱBÞ;¯CV CÓÆC}wBã¾BBïáwBÛµ BÍŸÆB’zwBpBu_B´~øBÙº1BÄNŽB̃BÑa.BÖæ(BŒÙzB‘РBr5Bv BU~jB³^ýCÈCcÒC‚3C œæC½ûBv9B†ìBxXƒB`TsBhzBcißB™giB»@KBƇNB½>cB«BžQ”B˜vBj¹BwôƒBcñrB„çB€H-BrhRB eÊB•ÚÂB•; B›2B¢TBš-øBd(ABmœpB¤¶˜BÔJ_BÒr½BéO›BÕßB¹nèCÉCNÚ!CSŒ CKjSCEâvC$ù>B‰cæB„6çB{R BH£B}ÞîB[o‘B‘P½BqëSB|­)BlBJBˆf‰Bj¬BX$MBU£ëBHŠBW2ôBeÇ£B‡?XB7¹B’=GBŒ‹B©PõB’·àB†•¢BCîGBS2ëBµs®CX_C‰ÝC  BêRCBÅk¦B·CŸB¿U{C`B÷ìvBîäC¢CÓzBèáƒB͈B×ß2BÃ)ÄB‹öBZÁ‡BQßBˆxÎB[LB]íBJê»BŒ"ÉB £®BÅ'Bž¥¶B‚¿BV‰#BtýñBš|3B•újB‰ÆRB™B…,B‰DËBháÕBˆ“IB óBpŸ-BVðÃBaÏHB]ƒµBwòBLŽüBwABw1)BkÉoBCæBAÔíB]Í–Bz hBPçB«ÈDBg#`BmÝ|BƒêKBHÔ¾BVÖOBK‚B€nxB­§¶B»àøB¢‚1Bn€†B>¾»B{ äBÓTBŒÓBˆŠÜB•9JBŽÅ B„ yB€ŠBŒ.†B‚TýB„šB‡ÚÌBƒ ùB[r~Bƒ¼ÌB€ÛnBiUeB]§¡B†.ÝB@)BW˜#BXèëBl$ BaËÜB§SBãÁëBØËœBãyr$BZ–îBb’1BbŠ€Bl*êB{Bk ’B¤˜(Bžd©B©NhBžîB‹±-B…uýBƒ‚B†eäB¼ïBÖ¶jCû@C ¿?Cg}BÎlB›nùBÁ@3BÖ-àBØD}CFC¥ÓC %äBñ,ëBêÐBßkBBÄz£BóŠBl6tB\fcBƒ–B]íBS-ÑBC7JBbÏ»B«'B²¯\B›y@B†ÈBsžB†b6B…ÝÍB†ÏB~FBœÌnB™JYB†$SB‚=BsåCBy:Bk=ÎB‡&èB`LBu0IBr(B‡˜BP©BqÙaBuwJB8t¾Bd B|ºÆBb·îBk¾`B¤¾Búº)BÉ€nBæ—BÎðóB±røB’¨ÇB” –B*­B´¨B´N³BœÏB§&ëB° B§’!B‚i¨Bl¿Bw~ÑBèÏBsM¾Bv$ªB„Î'Bxe–B…6{B†UBˆÃBn€æB[sBÌ(sC MƒC%wC8WC Ó*Bú ”B•¨B‡™‰Bu`ƒBiv„B¦ÌB¿EBʾêB±Ð=B·šB¨ã¡BzŒŒBy*B|þ‚B{—ÚBh1…BQØBhuÊBUËêBƒÂ]B½°"C!%C"îPC6ë^C6jÃC&b¯B«úBuªŒB‡í0B~­EB‚Ú'Bž"BÕ{òBÆOÓB¶ŒBB×Þ B»¥BsÄùBpÍ]B{©)B|ƽB|ÁîB–BiCœ~CãsC'Þ}CËÙC„+Bª WBT­aB‡EfB…ÍqBŽ BræB]RÕB¬ªtB¸ö B± ¥Bºæ­B²-B‚›§Bjn˜Bj}ûB“À•BsΗB‡èÝBdúrB‹È5B™`÷B¨"×B™3KB¶´BrŠBs÷ïB„nBª¨ƒB½”»BÇ»HBêÙ)BêË9BÃ-lC$(úCOˆCh8ºCM†œCPýcC$%B£>ìBq!ùBTŽœBo¾5B:+ÒBRŸkB…«ÉB´ƒB“ç‡Bl¸,BhÑ#BJcBnÒBXi%B€fEBbœ­Bv‡´BUb%B–‹B¦h‰B­MB™!üB‘~9BXó›B~+wBsÒBÀ‹bBÞÚúB÷ÒOBÿ÷fCÑJBÇùMBµ.BÊ9CBÒÂÕBî`‡CGCs¥Ce†BÙîhBñº7BÕ4ËBÕxB›zwBv¸¾BgžgBv•*BséƒBp9HBDà2Bd«™B¡ƒB®IB¥¥ìB—ÝãBÈB”š,B–±B˜RñBœ»ÈB¡%BœÄjB~dBƒ hBs±»BŠýBsyBpñwBv9cB~B†R BŽÒ¤BVJB€gBuÆ?BSˇB]†]B€º÷BzKdBxzÿB¶–TB效BÄóÄBã`BÑpcB»CõBœ©^Bjº—B—zrBªƒþB¤çïBšócB¦W¹B£zB–€rBÁýB…rBƒÉB‰>9B~ùDBz¢±B‡@!B|g“Bw-B}_¦B/?B‰kkBù§BÁY¥CÊ`CJCCþÈC ¥ Bì¢dB“AB;¿B{ãØBmÞoB­œÇBÀ#BÄ6WBÆš[BÃÿˆB¢uB“·xBlà–BpqBiˆÑB†¼áBx¼(BdJ„B‰%´B‡ÞÈBÈýäC'=qC&òqC-sÒC3ô=C%rÊBŽóÂBQÂBnê³Bj¥oB| B¨›B¿võB­"©B³ÏËBÓ¬Bµ!JB†±WBƒ¤“BnwPBhè?B‘TiB¼'ØC'·C%\2C*­ºCA¥CªÞB®˜³BL“BÁDB…´uBhU!Bc†\BwVwB°¤BªOBÃŽB®ÿB¯_B‡ØˆB€*1B_…]B†x!Btø²B}*ÅBpxÇB‹ÞVB |°B±wËB§‡’BŒ¹Bg}¾Bt÷BÛ}B¹…ÏBÆè>BÕØÀBâpLBÝj?BÈß CíÄCK C\NüC?zôCXòiC-6†B’6_B_.ÔB^mŽBoÇB[ærBe\B…sB~èëBŠ`B`óµB‰)BTîËBvá'BG|~B…ZBQLýBoRŒB†áæB˜¯”B¥P¿B ú¦B–4|BœFB]¸ÉBlìBpŒøBË×8BäÓÖBþ•Bñp­CL„BÉŸéB¶îÔBÕZOBÜÖ+Bú–Bì|C5ËCµÈBÕûØBòÝBÓcèBÎTB‡è¦Bl¬.B€¬ÖBûBiغBc8[Bxï Bs ZBŒºBÚy±Bß ÞBÈ$Bà"\BÛàðB¶ bB’MiB\ä6BŽ‘¤B­ÀQB°´B·?B¡ÛœB¢4ŽB•VUB‘¥$BŠ`B„]Bih Bh­‚B{zBŽÕnB°©B†0ðBsVYB†7«BŠ…—B‚h1BÌ×nC áC.íC<˜C<=Bó,ÝBŠ4Bu B†oëB…d!BµY€BÁƒëB¾5IB½ÊB²N-B¡t?B•ƒ BWú†BbÓBЍ¯B‡utB„`þBm*B€bâBƒukB¿ÉœC(rÌC-p®C=‰C!C7L;B–‚ÏBfVzBq2FBlܪB‚!B¤Ü×BÒ¿íB­….BÛG“B×ðÄB¯mB†|æB|É“Bu!BM%tBŒ;‘BňC'[C%úYC0šKC&§/Cû¸B§üÖB~âBŠn‚BûØBlÚ½B`O6BˆªB®É8B¡ºBÃ}¯B¸´'B«<B0‹Bzø1BiŠªBu¶ B{S‰B¤B‡×B’úBšI£BšÂÊB¦Æ¾BšñB{¤NBx…EB„üIB·ÉŠBãž/Bò" BéBôzÿB݃5CñCHÒ„CO CO@mCR«.C&B‚Í¡Bd™HBn ‚B^ÉÉBb¤SB‹(‘B‡í+Bƒ†ºBhP>Bt£ B|=1B‡îœBpïíBt\ÚB{™»B\éûBŒ“B—%PBRäB§sÒBœì¢B£¡B¦é×B†ŽBmªBvÙcBÀ}kBó;CÔ Bûd:Bû£5BÞú5B²FBÔrCøYCBê†íC ²C‹pB÷ëÄBí¥BæBÉs¥B¥áåB‡ËBpúBk+B~õB^é„B\^Bq‹B¨ayB°à'B°‡áBpBk¿ÊB’¨HB¥s'B™×ŸB›èLB’_×B’­B~™ Bw\HB‰›B”LB„ŒJBnŒ†Bˆ½zBnœÖB…ZBgGB_› B… ÒBRB}BˆÕwBw-DB€Å›B‰=‘BÐBÖëêBºíþBÐA™BÌÍñB©7dB-Bgµ²B‰³B¤xB£¯ BÁ1[Bš¶kB²;B‹`wB‰°½B„»þB]xBoNBquB”Ë BŽÖ†B…’åB†µÂB6BõåB}5‡BBÆU8C bºCu/C òC“’C);BŽ%B|ÃBUmçB’”±B¥ûýBв”B»õuB»jB¬Þ÷B®\²B‘¯^B†/BO+BýB\±ƒBmPOBv‰×Bm5bByÃÍBÉßòC%C;/|C!ñCÀC/ÝjB¸Ó‰B‚“BddBdù³BwwWB´ù{Bè…B´;BܬêBÀ8B¬pcBvMCBxÄþBh]÷BL"BdAB­V­C%ŠßC'äŽC!:OC.E¹C³B¢ùÍB]œ B†_8B^% BP­ŽBb¥ŒB‡ÃxB¶œµB®ÈÞB¼{BÈÃUB«¯šB”Æ;Bw œBZø+B`YBq=B™IB†}‚B yåB™’BöüB£ /Bƒ–BwEWB‚®þB‹“nB§y=Bæ8©B÷ ÒBäsÆBïÕ:B׆¦CÅ7CSi¢C=utCa1ýCQxGC]“BˆsnBYÎB‡¸äBFÕB:ʰB•NÅB‚”BƒByà¥B€0ˆB‚y¡BkoŠBn¼»B†ƒÂBzàiB[öB‹§ŸB†QB£,HB¥§`B›pzB–€B»&B žBbð‹B…ȽB±6€BïhBü[C þCßfBÑ=…B¡é¯BÈ× CdBùÝøBù~MC ¼£C á)BøñoBÙ¸/BÈèB¶¤âB–7ðBx¯Bg½cBáBq“§BN%|BmbB6üB´B§á6B’QÂBs¡?BkB¶B‘9B¦ÕB™qCB–äÐB˜ßB‡4eB!‹B‚ B€ÏBœ¤BhwäBt«BŽwgB‚ ÜB’€ÅB‡NÈBf`€BréüB’S1B]áWBv5`BI]B„µÛB|c’B´‘BÈXKB¾BÚÚ BÔóvB§MB…vôBqU B€­zB¸,,B« ‡BÆ;®Bœ÷IB±¹7B‘TíB{á B‡þB}NB_ý¡Bƒâ¡BçPBŽvÌB…ÕªBt&1Bƒø¾Bƒ0Bz öBˆeB³©ÙC ñ?C Œ‡CºˆC¡õBôzB„­ƒBƒõaB`¦ÜBŠÈ}B¯·ÁBÁq>B¼÷BÍ^B¿¼µB¥2~Bf'ƒBŒ‡ BQÚiB„KpBi ùBZˆ…Bì:B†/B‚ÑŽBÙÝC1(àC8¨ÓC-ÝÚC.ÁúCPÎB®Ë³Be'¾Bt#OBˆYåBs¢wB­û†BäLBÈñnBÒ OBÑßBµº±BuŸB5ÉÐBhj[BqlBnÔ©B­¬3CúËCÔŽC3CÓZCóòB˜%¢BkÍ©B~BEûôBiGBt²”B†üÛB¹¥“Bº£lBÖ8vBºˆúB­{)B–SÆBvf'B`ƒHBkjŸBhƒ[Bdº!B‰SjB—¹wBˆ`Bš@B™Â"BƒÂæB{ B‡M¡Bz<ØB¤tBß.¯Bç BBÛÜBçîBÓ5ÊCtæCE¼,CECbm–CLRµC (ŒB§?BiHyB•ƒ™B~g1Bl—–Bú+Biv B`ÊpBaªzBhÛÑB‚ßB€«B‚XfBoûÚBk·‹B<(Bƒ´zB‡:fB½ÿB¯BŸMØB‹³–B£ÍBŠÅ B^¿\B‘AB¾˜áBðô1CKCoC bBÛŠzB¢Ç¾BÆ8ÌBÝ™áBßm/C>ŽC šxCÙ“BúƒMBàï>BÆóB¹uúB‹É³Boç¨B…©oBx^B}î BZÑ™BwÍÅB€‘B¬)´Bžƒ?B’«DB’OBiO_B?çB¢…æB“‚«B”ÓsBŽ ÇB„ÊÃBƒ’sB€ƒ‚Brx]B|PðBi TBk´|Bˆ÷B‘+óBxÑ»B‡Ÿ§Bc B€lõB™æ™BkžkB^îB‚mBvÚB|BˆÒBÁâBË3.BЧÇBÛ~ÅB®³Bg•B]ò9Bƒ¿^B¤šâB­×ÈBµ¸šBŸFòB­“B“ BqúB}–B|¹ Bxœ+B‡YBnÃúB„q@BƒDJBŒ×ºBŽÞyBq“5BŽöþBeýÕBµiGC CêC;CÏ|Bë+¾Bzå¾Bmê¬BV‚aBl®TBªváBÂ~ÉBÖ‹wB¯XB­GB‘©`BR¤õBuÄHBcQ7B€FmB€ùFBN¦ØBƒÊB_šBB’ùêBÏü C+_ŒC"9÷C&l>C3a‹Cü›B—ù¼B[ óB‡¸¬B®V´C ³CurCØC-—CÐTBTžBmgBfõèBXhêB‚}@Bw³yBldIBž@íBÀTBÇ„B©á\B®åB‹@„Bl{]BeÊÞBx`BY1áBk`¬BìBŠæ"B‹õÃB“¬GBšw7BºŠBz¨4B}MBc¨·B¹U™BÏUQBÕv‹Bܘ€Bè*þB¸(¤C;DCF tCGþîCIí)CBÓõBª;RBli5Bk™„B´ïBŽCB¨B§Î¦B­9B£ B‡B~Å3B‚f¶BI—ÄBsæƒB‹ ºB{~½Bƒ_EBLûBŒZÈBƒ|™Ba £BÁTBƒ»BÌd}Cr^CHCáC\nBãÍB‘‚BiÕ˜BoM˜Bƒ/­B›DB§>æBÔÉ BÀ›0BÄ# B¢‡±B€-Bbè†B†èBd8Br{B\šBõ`BaÃBˆC:pB ¯Bm„ÜBw…nB[¸B@óFB†YÄB_»B²î¸B°låB»kÊB´ü3B«–oBsÁBk\ðBe«@BmgBa(rB„ÐB„À¢BšT-BžB“ï)B’ƇB²BM—ÎBiÐÉB…BÜæBÌÔýBÉ9oB㆗Bî–PBÃuõC´tCV5§CKŒUC=$×CBH´Cò°Bˆ†BC˜2BJÿbBw [BCñžBhš6Br@fB^°·BoƒoB‚ʶBšÞBYØVBhˆçBj§6Biá"B‚ÚB^f®BmiðBšB£¸ûBšÌ^B‡¬µB¶¤Bv”Bm:ÓB‰ïB¶$BÝËÅBô•C Bÿý˜B߉pB§ç+BÔÚÔBéCBü‘&Bô{rC CÚäBñBÍÍB¼ÕTBÌ}}B’VBÉÆBSÁ¯B_ùBb¼KBhå6Bd‹ÁB†ølB¨ÊƒB—ÆpB³.6B˜åSBr·mB‡øÂBŸ&;BkBBˆ’ÁBœ¡ïB„-FBs*‘BWlBzB‘)æB‘¥2BƒŒBv†DBe™8B^OBsŸŸBƒ˜ŽBW°B‚­{BŠ êByiBd Bq?OBƒŒB±ˆBÜVYBÄ—BÂÉíBÔp/B¦ÒTB^dìBm~KBˆ·#BšÜQB™oåB£(B¢8íBžPîB”õCB”¡œByÚ¶BfïtBtèBm®BfS¯BXúcB~RBŠšB‹Y§Bxþ…BŠÚ@B€XZBÔC aÁCLwCpAC ]/Bæ)¬B‘Í“Be.jB’5kB}k5BœåB®Ù!BÄhB§x¬BÃ=OB©ÅB‡†ÏB†¬B½±B~í¿Bˆç²Bjë¤Bj[jBäB€øsBÆiSC(L\C9x€C4u’C5£C³YB®?ÄBlê8B‚¤Bˆ<ŠB“6&B˜Ç%BÅï±BÐH¹BÛÝ$BÏ4B´‡tB“§!B_iB\ÜBeOB'BÃ9ñCíC/×Cy›C5:rC(C´BµÏVBdzœBu¯hBdÕôB0ÂBBÏZB…(B¥îíB´‹ÈB¶¥ÂB§VBµ¸¾B‡…^BXøvB[ævBfCBt}£B€ÚB;¡B‘ð0B¤ëOBž½B™©B‰NBZVvBSY B‚^$B¢µíBÂ^BÇõzBÚï¤Bå&‰BÆo“CÂ:CUz­CA²CBê C=̬CÂLB^DBq×ÁB1¼ABhüsBN½B}Ñ"B_‚Bs†BSL‹BÃ5B†Y^Be9Bl¼BdMBo®Bp’ÁBc MB^ÄB‹-lB§,;B³{/BŸå½BžrB|EñBG‡BzœñB¤ÜãBÓâ[Bì:C c«Bÿ.òBèqSB¡–éBï»Bíb´Bü ŠBôÿ½C%úC?¥C®ÌBá+OBÒOyBµlLB•ÃBqÏBk).BAF!Bx|¶BzG]Bcs%Bh‚VBÂBªýWBžv»B‹cB[„_B‡ îBŒxµB…SB‡ßåB’ðNBŠËÑBT>öBÑBƒ—®BoŸBy¹×Bca`B|scB‚†µB‚ŽÝBirÉBal†Be¶,Byï’B‚M#B„žB^æÈB€ BoªB¨çBÚ5rBÄ{KBÔÈBÛ‚ïB¤B[OÛBnH“B‡Q%BŒòB’æ…B¢nôB–ÜðBœå¦B–:B’²™BŽc;BhÝBx8ÌBgâBx¾tBN,gBcÆ2B…y‚B…–B‡ÆîBsDBtÃBÌœ…CtÅCúÊC ÙKC ÊÝBñÝ„B„M‚B[  B”ÿ‰BjVBpwBÊ;bBÆÇ¼B¨HB¼ô[B¡ü‡BO „B†ÖBkº»Bf~YBƒŸôBnBÎB`ÔZB~âBƒB3BÁyC.ª~C7ŽsC.ˆC4ÑøC$ô®B§5‹Bi1±Bs¤¯B~óB‰wB ¬óB¾BÀø=BÉÌTBÁXßB¨ßB‘º Bg±Bd(FBe”²Ba(÷B¼àC’¼C'ÀÉC¬¥C'3pC!hýB­|EB_ðxBm>:BeEÙB7"WB€ÃB%rBšþBÂ0BB§vîB·PœB­·B‡KÚB`'FBp§NBUN\BmvõBl:B…¾BŽvòB›ËëBŸ¯B¦‡B£nBUÑ!BIüJBˆ¸GB´jÉBÍH¢BÍ£€BñD'BÖ.þC["\D’ß‘CO„CR1lCV²C8m†CúÞBоB‡fÇB@VBYÉyBKÔBƒ™9BMz…Bu,þBCxBsÜtByì_B]…=BvÊtBH8^Bo!âBVµùBx¹¥B`FBˆêGB¤Õ_BLãB«MžB®±gBiÎlBXùÇBk‘bB«\ B×AþC¸Cj¿BùãÖBËE¼BŒüBÜoóBþW¼Bñ kBúd¯C» CfKBÜOCBÝ‚BÞáéBÁ…BŠ—šBéB]røBST—B‹VwB‡/BxvVBVyB©¬\Bºo«BœJýB‰ÂRBc…pB‚u¸BˆŸ˜B ˜B…£\B‰f5B’ù8BsîBj3>Bi6åB}º,BjBT7ÙBk% B[8+BtBaÏBg”Bn6ÛBt$B`ŽzBŒºBqôlBwGÛBnÃæB°=ÜBÄ6BÌá-BÚè±BæT¹BÅ CB€©bBt ©B¨S¯B¯S‚B™¦Bžß€B›Ë B·yBm˜ÈBŠkB…­ BXgËBZô­BlÉB BjsùBa»JBx4)Bz˜¨BM©ÍBr‹ B|ëÙB»¼lC¨sC ÎEC \XCéBù½ñB”§(B‡ËÒB„ÃÜBjðBœB´mBÃKƒB§wB³Ž­B©/BaÑgB€É˜BbtÝB}vBoH‚BlçÛB_cJBÎNBsÄ•BË_KC6VyC4àêC(¥¬C8J;C#Œ%B©ªyBlçÛB‚0»BmºoBU€B¥Œ%BÓmBæÔ›BÛ¢Bº!ØB¸äŠBŠ÷\BŒõtBfë+BP¢aBeP˜B´õTCβC!cC#ºÈCPCB”B›Ï^B0ÞªBi»\Bd¶¿BPÖLBsGB…gÎBŘïBµŽ²B®T8BƬjB¹’B÷)B…(WB†óõB[OBx‚ BiìfBŒ*Bˆâ0B®B‰F0BœmŠBškB_N"BQMˆB† WB§ô~BÜkµBÔl™C°"BÕ“OC·4˜E^ADŽÊCXîuCL"DC?ÿÈCeBˆÍƒB‘”$B_"ÝBJ(°BOšêB_–@BTBBu<‹Bs\½B†q0BB§ŠBl\B‚5Be“æBbXB[äBX´¸BzÛ÷B€ÙñB˜ÑBlxB¸©BxØB_Þ^BƒfÓBh±B¼¹NBÊeÇC˜CšÁBü„ BÆ,ˆB« êBß[¡Bò Bõ>ûBößÎC8ÉC€’BÜ&{BïÀ¼BÔprB²çÚB¢•B—ôBh–Bg«Bz­ÏBh÷5BkpBmä½B§hB¥|QB¡ƒ¾BvPB{fµBŠàêB“èB‘­lB]\hBMˆB S•B†©}B`-òB[c¸BN@¶BuêBq!Bv–ºB‡tB‚ÀCBS‚àBv°¢BaþVBoWBm‘=BlAjBfÙBnxyBŽ3€BÂ7FBÂeÏBÆCÖBÛ¡–Bä •BÁ}ÆBULBxš¥B‹ëcB·©êB¯’ÅB“”qBªlüB¤s©BWt B{ôVBy†8B†õ3Bbï‹BlÙÿBoè¯BtºWB…ÅÖBtÞàB†Ñ$BWŠ>B‚ØQBhABÀQÇCuHC¯C7CË"Bô1B‘cbB‡ÿ‹Bº½BaÁžB’™öB¼†%B± ,B¾¡‘B¯ñB¬¾@B\“©B^áBbÆ2B…sŸBu %B‰<ÚBul9B‚ÂBY°=BÄ^C/qôC1´C8ĹC>\±CbÞB¬ÓãB_©Bj>±BtP‘B}AüB bÌB˱OBñäœBÜC›BÈÓ-BÍ)ÀBu§ÖBy'Be•mBgWmByõÂB°±ÊC–CqîC#º®C$½C ¸‹B¯§ìBMÌBX/ BO®µBPðÒBR'fBŽy;B¯©]B¼¯B¤!ïB±ˆ±B¶ÐœB´Bz[­By­¤BqWB\täBv£ÂB’Ó,BŸòB~ÖËBz…Bu?þBŠçKBpþBw”$B~ÏB® vB¹õjBÑ0„BáéBÖ&CN!8D¦2Dÿ}hCRdCMF¶C?ZLCŒ0B‚?éBk°Bpþ’BX?ùBmïáBVJ BnÕ°B]S÷Bi~bB€Ö`Bfù1B]ÕÇBZϽBlçuB+§§BKq"BUÿ BsêB€ ~B¡îxBª`{B}g|BŽ^OBsÇB…ÇGB”ÂB¹?¯Bêƒ1C¨bCðxBõO!BÆn2B¯J§BÀ;.BñpDBùBþ›CgCPƒBΓÄBöRBÙB´šDB“;ûByø¤B``¼BnyaBQ’\B>Ê®Bs,CBk/B¡“BšàõB˜ÛByÎèBŠ1QB~–@B‘ñBŸÛ(B^8B‡J1B…±sBξBk4½B€÷BUuÊBŠ£Bs$ïB…jîB„1-Bq§B^ˆ¶ByÖ•Bd8ABkB,BXã¸Bce*BˆàBriÖBq•ÉBÂÙåB¶½OB¿‚BÂ5ªBâ' B¬äxB~ÜB‡õ4B€Y"B¬n3B§×¯B˜À;B¨F½B£ÀBd@Bб¯B„{MBŽUäBy€ìBtàPBt2FBͺB€®µBuÀYB‡ùB„OBƒÎBxš'BÑ“OCDáCˆjCâ¢C"€BÿštBˆÕ>BqÍÆB¨BzÄB¤"¦Bº¨B·Ç{BÄ@¾B²QhB¨= B|(ºB‚võBƒ=þB†Š´BoüdB€tB€â¢B{°‰B`É B¯ÓmC'ž;C+ªIC3¢C<®ÃCæîB ÀÉB†éjBVù†BYHÞBEØB¦ þBÓ‰;Bá€9BÁk¾BÕ qBÇ,VB}’DBaÇÜB|ý:BoÐBhƒB¬#®C#øVC «²C+þkC0w!C™!Bœ¼lBv±BVÁBQ‹$BO ®BU„rB = B»¯õBËô_B—°B¯®B­.‚BŒ¶ýBm¡‚BŒˆÖBˆ ×BQ4šBvÄíBsB“lKB™ñBÉÆB“_B•¦BcÌ4BQ®¸BB²UABÁÕBÝ’BÉ]dB×Ú„B¼ðC¬¸õDùç#D]—QCO»CMC°ŸB“áBlÒÇB\ØgBrÐmB„ðBb\æB}tvBD´œBgª–BzöB{@ÿB{bBc_ŽBfˆ4B>ÁŠBiŸŒB|¬uBpÚB‹oB¯ B£6—B—òvB Î?B–œB€¤B…[WBÏgBò6CVC³BîÜãB¾Ž’Bµ< BÅîBä¶ÑBè'•BóÒ™Bù#¦CÙHBÍ÷BâôÑBÊ4KB¸ ÔB} §B{]ØBp§‹BU¿B|‹ÃB]+B`÷5BikB¤õ4B©Œ“B—¾ BÙ3By¾B†òB‡B‚•BBŒÅ¡B“òB¹WBêEB‹©$B}&,BtBˆv²B‚ÖB‡.B^Æ|B~ÍNB}#KBo7ÂBŒRøBt7·BPð BZèJBphßBslNBuù¶BžßyBÏx¬B¶JxBÆvBÙ]ÚB¬VõBk‹‡BìÐB¶B®Ü&B¢Œ·Bšr4B¡â†B®rÝB‡HíB…/mBxÌÊB€—xB‡B€¾äBŒˆ1BÊ3BˆžEBySgB‡Bˆ¸;Bï8B‰@JBÕõ½C.lC A™C"«C«uC¬Bšó BjBB€äBƒ´B´ÕyB´hÑBÌ&B´4åBÃÔhB–´ƒBƒ2KBŒ»'BŽÊBcO×Bl+$Bz‰BvBgûB€ZB»š)C)»ùC"ÑŒC(’žC)(aCÛ´BWB†-ÁBp±ËBV†ÆBtë†B–ü&BÒM¯BÏïB»f=B¾>B¼BBvîçBnKBw¯6Br&ßBeê/B©©ÞC& ¨C‡fC)ƒ{C)ùƒC gÏBŠ 6BrYÕBn–_Biy¸Ba¾áB\Š1B…¿-BÉô0BÃ+¨B¾ÂUB¼XB¶&ùBˆï…B…ôBƒàÐBŒÞBjXÌBW0öBZ¾”B—ûéB¤,Bµ!oBˆº(B¡èJBƒêmBO~ÇB‹{ìBÇž˜BϵCBæGBÞš·BîœMBÙwUCI¬D[¸ESÑCLÚ“CLn¥C!ÒBB,gBo_UB@³JBGnB{EzB€¼Bzw¶BVHEB‚ÔB‚LBu™Bi,ÌBy°¬BxïgBuÁòBqO|Bb¡ÍBXéYB–æB®v:BsBž7B•ÌLBŠÌìBq6|BsœèBÅò¶BôC C •Bñ‘BÝ/AB©GÊBÕ;3BßrBñÒjC©ÖBü8mCÙŒBÜŸBÅyBÓ=–BÈ{B”d°B‹h6Be¢B^ªkB€°xBsÇ7BE`fBƒJÐB¸_Bœ&ÓB‰fB‚ BsABŠˆFBˆJûB•õEB¡,‹Bi)B‰ùOBu BƒsRBzÌuBZêB`”B‹ÃB‰pÚBVK*Bˆ‘ÆB|:­Br\¸Bo5þBj|aB~ #B‡~KBŽB×1 C(ð_CsuCJ‡CøÊBì´ÎB‹QžBŸåBU4BwýB¬²OB¼ƒVB¾—ŒB® B¯gB°ç:BxóABY2oBƒ~Bi!DBX”½BeU'Bq MBŒfByÁüB¾| C QâC4ÛC+èC<¹BC'rfBªñEB_'mBqg‡Bnh9BƒeBB±ÝBºýêBÓ8ÈB»“êB×%–B®®B‚ BB‡Ê½Bs˜B}™Bg,NB­¤"Cn C+'­C'†CeCÖBžâCBhyöBTÚåBv¿ÌBS« B3÷¯BŠB¿ªŒB¯tŽB­zÊBéŸB³´‰B†KBLž?B|KüBa«¨BL@úBW  B‹ú^B†—†B—¦ÒBuÿ}B|ÍËB¶BqÔ/BjBtöBÅ›²BѺBËþÉBÐbXBî5æBÄirC`lC=½CI¢MCÍ–zE`èD†Þ•Bû@BmžMBQ0oB\™•BQ*«Bs—%BsªBj60B=ÝUBkBPƒ\Bn´0B‡x B‚ì–B;+éBYVBi¦Bz¬šB”vzBŽÛcB¯á6BD,B‹7-Bw28BdM±Bwí¸B¬øBþ‡ÆC yÚCá‚Bó}WBÍÓB«¯§BØ59Bø0´C¼’Bõ/yC ¡ÃC„[BéCBì„BËQ;BÈ'#B†KB‚×éBW½BGÔB^gBRsƒBX2ªB€Þ%B¦šèBªNáB¦ B‡ß–B‡ Bªý‚B‘¶=B}~vB¨ÁB™yB^p%BoP¹BzR¼B…ø¥B€¥6B„ˆ®BxlFBŸsBMÐÐBGïaBkBBzèjBd5ÁBl0B]ÝXBAšÎB{P Bq8#Bž®B¦DBÌâ(BÖ—kBÌ%>BÒå B«ÓµBc%‡Bu{B‹>ÝBª5ÄB¥£“B§±B˜=B¨ˆìB‚¼üB{ƒBVW§B‚+ËBo#·Bd6›BpáÝBwÁzBm£B_CMBÌ B| —B_ ~B‚~÷BÃÞûCÍ^CßÐC– C ŠåBà°]BŠãÿBrðÉB_‹jB\ZB¶JB¯M!B³÷ÖB´›B»yóBÚ«BdÆÖBY=öB}<\B^øMBeVBF—ïBm‡7Bz€\B{ ¾BÖ±¸CûÎC%AÒC/ŠC5»×C#\Bš‰GBdcÌBSIíBivÕB€ˆB±BÃðIBÞXÙB¬äMBØ´$B© ±BrÊTBiÛÌBn#òBVZ‰Bò:Bš^}CrlC*†`CéCC(xæC2”B¯3+BVjâBl7By RBa“œBSSŠB‰Ð…B¤§-B£YB·ÌB±ÂïB°ÉæB‰êöBV;BvmB^ê×Blm|Bfõ}BlªB ÚB%lB€ýdB’MBv¸Bsá,BoçÞB]óºB¾èOB¾D_BÍF/Bé1ÃB㡺BÌî¯C„C;ádCKÉC‡À(DvÃVE ß]BÒÍ‘Beþ_Bl¬òBK BG|ÇBw_gBcdBD³QBE–=BJîB_áôBejLBV BtÁ6B`ÝàBb«jBAš BXý‰B‹ïÉBi1B¦#vBˆ¾B†×vBD2yBfÞiBk×|B®ûfBû£C VChÏCÈBÎs%B³Œ%BÌ^tCJlCl„C ìBÓ’3BÛ$¨BÜg@BoBW”õB\ÓDBKü³BC¨ùB`óB5ÔBkªKB¦ê‘B›0ÏB­œ6B…‚§Bw‡öBŠ+KB‰å@Bjû˜BŽz9Bž›B‚NÄB@ÏpBxfBòðBŠÐSB‡¯BwžþBW(ÝB@£LBb æBCBcÍ7BPa&BL‰¬BeìIB€ pBs~˜BeÓWBdWbB¤Ž‘BÚ¨ÆBÈùšB¿$RBɘÂB©eBUkéBQ÷LB“‹ÆB¯@‹B¤PB™\·B›bBšžB‡þ’B…ZœBm¬BrËB^®BvhB{vYBzZ±B„k0BPnþB€ò@B{çÏB]µB{_EB¸§C DlC‡ÛCiTCv³B÷Š¿B”ûBZq|Bnh BT¬‘B¡CÈB›úçB¼¯{B«PÛBºÆŠBŒ¥B^~Biÿ4BaSûBoåBg>BE §B[^Byn(BŠ»ˆBÉùàC*zÌC%[C(­ûC#¾HCB’ÍßBQ”BBADNBFÝõBX“B±*íB×Ä¢BÏAPB®ìiB±qB³k_BfiæB<ôwBkfÒBYºËB€x"BžœñC Ÿ‡CºÔCñlCöªCŸ3B‘eKB6nBD'B`tçB=‹mBWÚB†@kB©­%BŸ^°B®$B°|äB—ÿ2Beš5Ba~IBc!Bmu½Bm[B]A­Ba„BzA²B}‚cBŠ€àB’áB„™ÓBLB;þPBR¼iB¯B¹Ú{BâjBç»)BÝеB¾}CVJC4áJC;y¿CR™¯C·#ÕDáö+Dþ¶›BIPáBo ŒB4!ÑBJÕWBu¦ÚBOº9BfžÉB[B<‰¼BX³UBG":B8©nBaúBotQB^X…BB4±BjÜ\B‡GáBž¿B–q™B‡B—BƒÎuBm· BTˆBmC¾B¬ý8BýwC,WCôËC ò÷BÑÔíB¯ø®BÌïBùÞkBüJœCß-CMJC­rBàIáB¿™&BÍWäBÓ¶BrHZBn.ZBfòpBe®fBMÃVBVG$BD[§BE ‰BšvëB—¤çB–b B‡àÑBj`ªBs4BB”}B„ ÈB•bUBŠÏžB†úBaãBxGBr%®Bo–ZB}²ÒB…c=Bhb6B‡ÔBx¶´BtWñBH<°B_kB;LˆB€éœB~ê¨BdUBsÚ?BM{BµXÙBÞµB»ZsBÆ$»BÀ†ÁB³!ëBfÉMB\ EBœæ–B¯«B°ó¿B˜ÑáB«ù;B’œBŸŠ‹Bu$KBfä:Br¶.BZšBƒ!}B€VBg‹ˆBf%ØBQÿ3Bv©·BaÿXBH¦æBuÜèB½cdCÓÎC~‹CîC HCÏÕBŒ{B[eíBeÌkBbÿB¤AFB©ÍvB³úB›ÿÑB°¤æB›¤xBcÚXBd¢XBeÖÿB{1TB†|BS ŒB[3íB}6B€cB´G/C1å)C0 ¤C&ÒCѾC!bøB¦GB\7ŠBJ ¡B\ñB‚ÿÕB¥Æ²BÛ:ÌBÌÏuBºù›B³ÆWB·Ê9BqÛéBVfB|y6BNÔ Bhñ9BŸ•›C'%ºC7áC&¡„CÚCªFBŸ)nB^ BOÔeBl†‡BM×¾B_X€B)B ÒnB¨JqB¤ö B¶R¾B«(B€³ÛBaâBu.Bs27B\íEBpâàBg»œB„EPBŠèYBŽõ^B—Ð0B‚ËéBSkŸB8AÌBl5ÃBµ§—BÄïBÖ–Bä(]BõŸüBÄ!ÔC¸´C@¬SC8”²C?ìCQÚßDqcEmC¹-BTGÑBB§SBDn"Bq«ÕB`‰BgBLŸ>BUÅ‹Bq}®B?bÊBG†pBWsZBTïB^Z§BHT5B… ßB“pzB¥sB¡tsB£Ç(Bš¥Bi•¥BuQ}B„nB½FBû0üBø“ÂCÃÚC›7BÒ£ÃBŸ5sBÊp@BÜ£ÚB÷å=Bù1rCÔ2CÏBìÜBçlBÞ~_BÅÏ(B‡ÊBc¥uBe¾õBIHpB\®ÅB€PÑB@{ŽBJ<«BšãÓB¤òœB«S-B‡~Bt¯CBŽIŒB’ ŠB–mŽB÷þB„"ÆBЇ¨B†ÎhBcmÇBƒ9Bqj—BnûáBƒº0Buæ"BŽ«åBa‹'BC3%BJ BYdEBQ;vByÞ;Bj¿©BeÄ€BtMdBsRB¯­ BÏé8B˱}BÎB»¹>B¨/UB\þ3B„@QB‰ršB¬¼;B¾øB£Q©BŸ·B¾¾B’ÌÔBo)&B}ZÌB‚S‡BK‘¢BaÒ¼BF,ÞBvãB`îÙBs3ÄBA’Bc²ŠBbÅ B_œcB¼˜QC ͤC´€C¡ûC FC6Bœ@BEÇèBSÕBf&lB¢K)Bà ·B¥R(B¸€¹B®w€B‘vB†¹Bcb¼BtÌBn¨MBsÍ›B/9BˆùrBˆ xB€VàBºfMC(žËC1:'C&aõC-ACdéB—ƒBnßBbò;Br1B[xBŠèBÓˆkBÐz5BÒ:ÄB·V¦B¼ÒùBn¨MB^!‹B|UBZÆäBp@ôB êC%NöC% C%sC'£˜CB¡ôŸBhרBuVàB`›2BTBzgBŒ¥ÔB¤„dB͵BËü6B´–SB¥¡Bn½uBhBdþEBdðÏBh‘§Bk>DBwÏ‘B€B4B™$bBó%B¡ ÛB…ŸGBll0B:Æ›By•iB¬] Bä%ÆBÙÈBåãBò[¾B¾ %C$7ßCRé°CE¸ CO˜iC;½~C[üGDOÑ‘D¾S—BnëByNABQ!Bb–ãBi ìBlqõB}TB‚JB|LšBë¯Bd‘žBWjQBB=.BNaÓBhç;B…öÇB’Û?B§Æ†B˜\B¢öQB¤ÐBl?õBzV®BaB»J/Bõî*BýßÐC7IBÿÁ‹BìÉOB­ÙBã²ßBÏõ C@Bôò¹C9îC‰mBé,OBò¬BèF€B¹VªB‡–¤BwK×BeYBVŒBWù–Bl§ÎB9‰LB@õKB¿æRB—ÕeB¥ë B„>B{±‘BŽ"¸B—jhBŒUBˆ³B‚?´B~%BwY„BaÑBBhUÏB|BrŸšBˆ”ÁB?âBf½Bj(BM)…Bg(‡BnñcBh-‚Bx’PB†uBQ²€BW4BhƒÝB¬¢BÂyBÅ‚ŽBÑ6qBÅëB¥V½B{9B„ûBS9ÀBš×?B¾*ùB®«2B˜c]B«!nB‘}ûBn[ãBxµáB2ABj'íB{êBI$BƒÍ«By†ˆBrývBF‚óBoM;Bk¥¨BƒC¯B¬”C§GCXC :éC °¬BüO–BßBi·nBY9RBvFÍB Þ‚BÛÆHB°YöBµÐ B¹"ÿB—JB‚iåB~éBg0PBh_2BU 5B‚PåBƒ:BÌUB~Ð`BðéC(ÇNC.ÊC-Ô’C-’òC7›BŽÕBmþBŒBwBaŽB‘óJB»RBÚLfBÉ»B²ï€BÌGwB€LB?"~BYŸ>Bh¯÷B‚~B¯ÝíC!ßGC-RC+FC î¨CBˆÉŸBd3äB¸BfsÚB0é(BVã?Bˆâ%B¬B_B·5BÄGàBÁreB¦/‘BxaCB„E`BY¯—B\âÒBaÕ*BQNgBwèB’¼¼Bœ÷õB—ØçB•uØB€+ÜB}HBEÚBlÉB¤_%Bà>BÒSB× DBßTÛBÉLCžŽCPJçCV.—CKø,CJ2CcC²ÍE(ØEÀ Biô÷BS]SB\žBa3 B^&ÜB\ƒ¡B´ÅBf8=Bx½’Bnê1BMsÞBLÕBHh†BWÈB–‡âB ²GBªúB¡‘[BŠZB“õ;B„í¥Bi¢FB|­BB¼¦ƒBíLÏC"QC³yBõÅBï.B¤­ýBÞT Bã0ZC€ÏBçþ£CdTBü«åBÚf\Bé@ÁBçIÞB¶¿B–áÉBm'B`ÞwB`jB«<BБDBÎ6ÝBÒó×BåH#BÔ¾ùCƒoCG¼&CSºCL£nCFî#CHAC$ø§DÂEœ%KC,ÙfCõC¤Co$BÞ|=Bâ’cBàp·B³çBˆ:Bk÷ÎBgìBaÄFB^”äBjÅBažÆBb˜ÆB›ZƒB‹•xBÂVBˆ.AB‰ØDBÏuB•ÓÀB—…pB‡yÞBbÞB€¹ZBd\BbPB[ãBp¶—B_©áB~«¹BmXøBXa—BdŠ,BN‘§BkºxBHÞFB[1BC¯MBcÛ‹BiêBP•ÜB€,ÉB¬f¿B»äÉBÊ› Bß B¿ŒÒB¥¹MB“x·Bƒ++Bu¶”B–…B›®¢B¨7ÂBšg;B˜þ,B¹•Br‹BmúÇBeü¡B}Q±Bw+¨B‚XBx‰¨Bi–BŸBt'‹By”Bs0mB„rB¾ñ C#uÅC ;C"C6aBí½PB‹! B„ë¹B€m@BL|ÃBšöûB¾?+BËÙÚBˤB°kÁB¢ãÒBZ²@Bf>But;B{ÅBsByßB`þ¿B† ÉBy§BͳhC!ÖÞC,ýèC'«§C$JCZB‹BQB{…B~5“BmªBeªæB‘Ä.BÅ" B« ZBÍÐABÉû}B¯‡ßB‚ÒµBbdpBbBÉB` „B‹ûjB·^˜C žçC3!CæzC"C†kB¥›~B4¡B%[zBF¿ˆB_W¬B‹#BsmBµÍ(B™hçB¡$µB¼ÖB±Ø¨BwèB‹v=B‚TDBj=B}Ÿ’BrmkÎBm$[BÅõB³¹èBݸ×C1C ÓBíG…BÆ–¾B¤k+BÈç‡BÙ‘ÝBîæmBü¼¹CÞCVÀBÕ„BΔäBÖ'B·=mB‰ßþB†Õ¡BXdÔBd\HB\¶BhÇ BT3ÁBfœ>B èËB™ÉÄB”n¨B‚¾ÖB… {BŒCtB…¼‚B†i²B‹èÈB†èB}Ë×BWˆBPqBMÔPBsxtBuÂB_öQBdñzB}HdB€ÎÇBS€ûBYu›B5(öB;°dB]þ–BHÝôBooB:ö@Bl–ÕBºïõBÓ lBº…Bß^ÛBÈ(BG BuêBw\}B‹TBŸðoB«ˆ7B àÑB¶%„B•$B…ÁB… ÂBn¢×BsmÃBjûEBy¯B„Å)B‚ ›Bˆ–‘B|éB†·=BsOôB{éßB•oúBÇ×ÊCgeC¨nC‰ C }íBñ’B‘9B‚ ¹B|Œ`By§B˜ê\B²è1B¼Õ BÌÃgBÊæ{B¡ÎÌB]ŸBqAB…–BeÒBiB[Þ B`š‹Bv&BŽÂ^BÚ|ÛC-ÏC!óçCé C"üCþB[ÜBy(BkxEBt;ˆB_Û3B£ÕBÅóB²&pBÆ>©BÇABÁ9‘B‚k>BjqÄBcè²Bo²õBvÄ‘B¦yC Ö#C¿âC%XäC*?tCdôB®bûB-½lB:¹tBNNçBI'­BvÛB‚W‡BÃaB“–lB¢ÔÑBÅ¡BÀ·GBhõöB‚”Bi¿ãBg– BvlBŽ-BqÿjB” @B†:¸B¼ùB’³€BT…BV:ÈBf%ÅBiXBÂ=©BÞùiBêîñBè—mBì]BÊ”FC¬)C=WªCHòCI1PCH CœƒB„•‘B’±CØWYDù݃CµÁhB=8Be¥ãBHhB[eÛBR˜BnŠÎBJ$B–ABM\˜BTÎ\Be`¨BKZ-Bm¹1B‰#éB›ÖpBž–HB˜oÄB‘àìBu`ÌBPL„B…¶BÀ¤‡Béf£CCBö| BÇ–ãB¨@PB¶DBבCBðÄBè÷”CMSC ºþBëCBÈY™BÓ]NBÀß©B”0ÀB€-¯BPù˜BHïèBZË BI|BQ‡æB^™B¤BPB¥™UBtB€>Ba!'BŒmiB˜ŸB†™hB–^Bn¥BeúBe!Bk2VBJ •Bp%B{ Bc}¡Bcç,B…²+Bm|•BnÔBLè¶BCTBBIÏ7B€ŠàBfŽ}BjŽDBHðBníB±œ}BæòöB¯h8BÚž÷BÈ¿B“ôBD—[Bob#B‡¹ÞB¯BÊp«B¦úTBº€dBÊDBŠ©Bzœ+B| gBû+Bg¿VB‰>ÎBn,†Bt.ûB]ÉXBlˤBR¯ BbVBmYòB}·\BÊðC l C©þC kgCª²Bþ©cB„ÙÐBz5Bj^}BrkB¤Y@B¨ÆlBÇ:ŽB©”«Bµq®B¦GBN²ÙB^GMB]JkBPƒFBsÅ6Bhµ~BW£NB†¶Bt6B×oC/¶{C†@CÁ%C%CÔBª-ŽBE!ÒBUcBrßgB[´§BªÅõB¿„ BÂôSB½\BÃ’ûB¸¾ßBeã`BvO6BKldBZ)uBb›ôB™ìCCZ¹C¹VC‘ C îªBŽËB[’ÿBSÍ”B>W\B]B`²ˆBƒšB³B–B B´ÑB´ÈB¼ùBaÑBmÕB„ËcBsyABKN•B~ÇyBx=qB‹LJBŽÜÉB”¹CBÿÇBmBYmöB^½’Bo ­BÁý7Béà>CüBØÑnBÚ@AB×¥éCZûCMœŒCJ˜¬C@ýC02 C)B‡^…BChyBîЪDH«™DŽL¾BTröBh;_BZØBn0^BlFóBkÕBa&àB‚zB_š¹B^EaBh¾$BlùÌBRíBˆ7ÔB¨ÄúB’ÍB¤±BŽSBdçsBfØ‘Bƒh”B°Æ~BöÏÆCQŸClýC *ôBàm€B£Þ¨Bª$kBåivBÞ TBøîCµCÝ‹BÖ¡UBÝ€BÑë‘BË"B…+Bb4BEåB\‘ÎBq{£B`èaB^3BvmBŸ\€B©wÂB›zôBZ#9BQ¤B‡¼ÙBšƒâBr¨2B‡ÊB†;"B­[Bxf!B{ûfBlMÜBfvBz¬‰B„¸vBQ†RBjšBBY;ýBv¯¤BO2zBF~ŒBKÊMBx¸¥B`ùB^rBP‡B\‡aBœ5BÔ0B²kSBÆ,BÌÜþB›txBROB_åBsâTBâBÅûBOòB¡!ZB‚’KB_‰°Bb+¹Bo)­BfWýBh.B{ŽBR!÷BW¨bB³B`lœB8 Bc’`BX1Bs&ÔB;CzC(C©,C}LBðEàB†9ÞB;üBcö`Bb=þB¥W·BŸ#¼B®%B©lBº¾‹B£‹Brœ^BYÈBO§ZBlšÞBb¡þB‚$®Bb××B|'¡BjEÂBÄJJC3¿õC,ãóC,Ù"C"–ðClQB¦„¬B_ƒëBe”ÌBZqØB{­„BœÛB¹¦BBÀžBÆ B§BŸüBjséBmÿšBZÌ:B]ÍuB~EïB¥:cCl=C!ÑCo$C¹íC }CB¡f”B„÷B[*uBC«BO3÷BcaVBKB¤šKB¡´wB£IEBÇcŽB»&dB{P?BFêÑB‡£BoãABE# Bc¬VB€GÁB„ÂÞBpÀgB›†BB„׋B}òHBj $BAñ¾B^eaB±>B¿õ(Bç²°BÕ² BÓð B¾HËCnCP1éCCžCBS2C/ÇÚCã±B†ŽBFÿùBd'jC6ááD“öÇD9èšBdy%Bk˜7BN0ZBd;›BX vBtÇ+B;>]BXaöB`žœB8€qBY¦Bjû|B}ŽIB¤°B™8ÖB_uBŽË"Bb<Bg0VB|25B±O*Bï4QBýùC „ïC ¨ÅBâCÓB’ŸæB¯¬æBÝŸÙBóPC áBï×+Bü 2CZÖBò¹ B”iðBoËêB[žBe^°B¦ãB¿©‹B½RýBÆ]B¼†.B–h BpõýBQ[BiJˆB|^,BIzBƒ,øB‡ÏB†0B„HŸB͇C1OÛC*>>C1°C91(CDÉB›Ï4BIœðBhû°BcÄBˆ¶FB—ÿB½¢PBÂ*iBÊÎlB¸9B–d0BhœBiúBk`BuÒ7Bh$MB¤³C‡£C#“ CÞ=C0˜C5öBš&¯BdÓDBlqBBrx‡Bn1VB;ÌiBJæ¾B¬»Bº*VB¸ÎBBº´ÌB°!B€AÛBS™©BvÞ{B`ÄÎBP¹ BX=(B²B†rB…rB˜BBK=Bƒ|ÇBlM¯B?:JBb”EB¤ UB­iqBÔjBêy"B˘ÓB»`éC Ø„C?#‚CNúŒCEr¦C@H‰C ýÏBˆgBh}ºBPÇB³lÜD àDë9ôCúXBpç‘B€aBkõ9BDùqBZõOB,ú/Bn êBXhmB?Q^B<~JBzÀBqÙßBˆíB °¸BŠärB‘‰B}¦BUŒ³Bv[·B¿ËBËÝCºÞBýšBüTÁB»…îB£4wBË âBË]°Bö .BôG³Bþä…C d¨BðyBè\DBþFB£»Bv›-B[»cB`N‰Bz{Bg'kBF`BK \Be%õB©ŸB£ TB›NDB„xBf~…BZvB_¥‰Bš”B†õ°B•£ BrorBo™BK³$BoD¯B|išB]„ŒBX’BLFæBaÖÕBtÈBgHBkàWB@·ÖBr~ÌBoysByLEBg§BsfþB^dB¥…ÔB¢ö€BØhFBÖA6Bµ!çB”µqBcz B‹.ýB™¸"B›*ÎB…‰RB¤§*B”«YB B*B—¬Bzb‰BuI»BzÎBwþ Bƒ]BhƒŒB‹Ú B[IB^%µBqêEBtÔlBoLBoPBÕµNBúaCªTC ¯7C 0Bú“¾By‡Bj·øBX"IB\Ð\B£W—BÂŽoBƸBÇTB°E2B%B€ö¦B†åeBd…nBkøBZ ¿Bs BŽÔ)Bh“äBŠÈ–BÓIC16%C%µ3C6ÛUC4mvCÝ8BP­B<êÿBU·BcŸ B€îõBš{ÎB±½(BÄgýB²ÞBÁ¿´B¬š¼B‡£LB|W~BQ)­Bp©BhÓZB¨ÖÌC FfC²³C"©'Cr?C $=B¦(½BTžJB]…!BVÖBnŸB,¢½B‚sæB¼6fB½apB¿ó B­V·B¦ŠVB¹¼B~®ˆBnÑBUèBv 'BPŒòB{~0BšEöB™[YBµÿBzŒ×B‡’Be B^HSBdÂøB¿3MBÞÈ`Bܾ¾Bç˜$BámÈB¿øåC šCHsäCQÔ›CQp CE~®CŽ”B€ÓŽBgé³BtÖYB\ IC"lÑD‹0$D^EâBj)Bˆ>B]@ÜBcÈB[fÓB6±»BX³{Br„BS$hBM¯KBg BBŠkQB“ºB‘áhB†ªCB|DDBBdéBhaBz§XB±QACøbCš’CW2CãäC³yB›?BC‰BZ½,BZRqB^t!B_ BrûãB±×ÞB´¬ÞBƦÇB¾”pB©`BÒBB†TyBƒI&B|øBihîB_ B½BšôDBš^ÀB•¿BНB‰²}BJjVB_Ï?Be/4B°X7B΄>öBYµ¶B0wBfqQBe4B‹hóB’ÞB§Ù8B”EBƒ:>BMABBIý¯B_ùŽB¥?×BóÓ§CBô,˜C XBº¤¿B«)LB±¾cBÂÜBÝáàBâ]ôCÞBýW9BÈdBΠB鹚BÊ‚BƒúŽBnÆB`B\åBEå›BYäÔBe;´BfΖB’hB‘ÃAB‹B„’ÑBqœBˆš¿B`-B–•BœúB‚º¿B† BV" Bk1hBpöBcŸ=Bm|œBcN¤BjŽKBgñ‡BŽ´PBlœB`,BI'VB;‰„BC…:BqÞ@Bp})Bc¼ûBj¤B¥W$BÃô¸BÄ®BÓY„BÉÁEB¢›B…#tBQ{„B†¹BªºBš÷kBœõB±)"B™)gBŽ|NBòaCÊöC½ÑBÜÅ BÒ-„Bæ#B³$XB˜WÉBsYBa¾øBW;¡BW*BIŠÔBV\BP±—B‚F¾B—ÝBœXñB‰aïBa‚FBk)ëB‘~¿B‹¢–B—ÇÏBÃ¥B‡r\BlßB{ÜoBx÷¶Bg¹B^í1B^͇BƒŠ’BxË“B€–BnÖ7BoC˜BP¬AB3ç:B4ÞÆBWövB€-éBd2;Bl¡B¥»ûBÖvBÊÔÛBÙÉBÕÞ©BŸýlB” åBuJ´B‚ÔBª’Bž èB“«B´€ÚBŒû’Bˆ/6Bx„ªB‚G2Bià˜Bm¤BrÀ´BwäBkúBVÏBvœ4Bã3B`nUBxS B€»…Bß"ÄCARCgCÌC€XB¼„JBÚ|ÞB÷y…BÖnhBƱC)æÂCO˜¼C:71CL,CEC ’ÒB„8NB]0†BdVTBFˆ‹By}³BgçÊC‚týDêCŸDƒYBgT¬Bf"BsU¾Be!7BP&BHT(B]ÑBY5LBQauB»fB“ îBìïB‹‡ðB«0>BtGB]…$Bn ÓB¹²Bó„Bÿß„Bù»âC BÄbµB•ŒÕB¿lB݉'B¾Ú]Bí–FC`ëC¨ãBíìUBÏ5_BÒ—=B¦ÉÎBžKÅB€CÏB=™ B3ŠBCÞÐBYÐBBv=B{ÿ B´\ÕB¥ ƒB¥4/B‰Å6Bhž^B‰"”B•fBÜaB¤8ÌB‡BÖB‰3ÙB‰7Bu¨mBpŸÕBÍÂB[›üBo$×B’â5B€GOB]†HBc©ìB‚BZûÀB4p`BEä¶BJqˆBlž$BT*qBg|šB¥IÆBÅüÓB¿ ¾BÒRBÏñfB£ß³B‡?ZB|7ÞB·øB‘BSB¨5ÊBžXÌB¢MÆB™˜tBiWB\ÙB…5¸B‰YTBKLÒBg)BeÎbB‡ùãBu _BXêdBk¥’B]„EB[2 BfëõBÐC !$C_ C0CEÖBñصBedœBu;hBIÈ\Bƒ+šB—ËeB¬ó»B¯—B¦uB],âBQ†2BeB¥B¾üBÏ}—BäÁÎBÓw`BÇB‡¤ÙB{ÑBX®âBnë-B]ÿBŒ;BKö)BK‡•B¢œB©4BR@BckLB_qGB‰t÷B—¯.B•¬åB‡[¦B•ñB„°BIsöBIÞwBZ5ÕBUKBzÞÐBeªBau|B‚6FBSb›BXÈEBZeÏBXá7BA‰†B7ÿ¡BnÛBF6B@“åB\9B¾BÁ¢ºB³±ÄB°”°BÈT{B­cbBnoBB|s·BtpÂB©ÕÅBœÝB¯eÎB®NöB¨ØgB€«VB>îBt9óBƒ©BJ¶B_ íBu®BW ÇBUSdB„TBb9NBZ×ãBR@ÛBVª©BºñCà`C„C0gC q CQ¼B€=¸Bo`BbþlBw~|B±BÅG;B¿ÐB¯ïNB¢7ÇB”œBnŸVBާBxå#B~­çBm,/Bt&¸BeHõB‡(B‚†VB¿›PC.~C&:ðC!àC5C=ÙBšž–BI}—B]e¼BbÍbBƒ2îBªþgB¹/BÍ©bBÎÎB´ù¯B°‡µBeC1Bfe“BŽTrB|(¶BaíXBÄ(C%ÂC a¡C ôCbJCó[B .$BJ¹ðBggDBSýBNRBO,eBjëBÀpÇB«ôB¹ß B¹ÑB©~EBÁXBŒ, BZ% BXμB?úûBM>*B|lüB€ýBy±òBIBÀ^BŒêçB}ù"BPr[BTñPB®¤‰BâhèB܃KBÍß:BÔäÒB„C(˜CFŒCªÐB‹2 B|<çBsCÌBU ZBO”>BL oBE]ÓBªOhCÕkŽDâôCÔÄÚB9åLBe¢bBY‘íBJ¨¡B6;ÌBLVoBE©B ­B“ˆ¦B«·€B«*¢B–®B’BINzB^J”B¾_îBù2C%CBüÌ©B˸¿B”0ëB°qBëè&BØBå¸BöÌCÅ‘BÇíBÒÈpBÓÿ~B±„BøýBzGòBK^\Bq¸BC:¶BHl„B)1B>A£B¨9„B®i'Bw$B€ÄýBgÏBy"ÎB‡ƒB”'ðB…[áB„¯,B“/nBCËBrTBJÍœBfÆEBSí÷BpylBTŸyBpGBquÅBuá÷BdÝåBa 7BC#uBK—Bi"B\l+BFç¿BlÊ?B¸%çBÉ‘šBÆó}BÒ%—BÒIB¦ø¼B`DžBh¯kBy¯UB¸g9Bœ?B¦2¨B§IB|ûBY¨PBw>UBiãBfBn¹‘Bh:Bp€`BV#ZBI9˜Ba+cBmƒôBŠe^BeBmôBÆúòCbCí/CúCƒCe;BpCÌBf—ØBtx·Bd2bB¬Q{BÓîRB¬Z#B¯"¢B«¤ãB•"áBd•lBföB~#Bë{BcEÙBm5Ba7ãBZxB‡ŽrB̶C)ðC"fC-šBC)‹RC ÚB“)˜BSõªBp‘¯BuƒB€ÀB™ eBÆBÍ?EBÒMBÄžžB°À“Bg'BeV±Bjø B‡øB€ˆÛB¸Ø¯C‘C;³C \^CgãC$&ÌB–ÆB@ £B\pÐBTá=BP–4BjD:Bu B¼'QB£fPB°yæB»¡/B±ŒlBC6BtíB^ïEBlB?“hBOwªB‹nFB–æÍB‰jãB‘]úB‡*íB‹órB|hBuÁBZSwB­w¶BÚfBÉ#BÆÃ¨Bßù÷BÒùC!TìC>AxCWXKC=ýìCNèqC§øB…—‘Bi\~BrjBJÌzBoÑ`BjÙDBTšB_ãCùÇD]cÅDò£¾B¥/ BW‹îBS BeÏØB;‡ÕBtd‡Bd‰âB†sÁB”wºB¥2iBŽ¿OBá¬B’DEBP–4BO™QB·nªB믎Büƒ¸BôcoBüÜ.BÕ¤MB¤…ÐB·„ÈBâ8|BæÈEBüîîC'C_}BÆuKBÄvJDBM˪BL NBO}ZBYUîB9/qB_öNBM2%Bˆ‰=B¾BÍcþBÊLBË.BʰB¦ ÀBs–çBN¡cBiÒèBâÚB³ù¥BŠ;B¯–’B‡ËB‰-çBgËB…î-BgBV8§B_‘êBWFØBx!Bn­7BO.¼BƒwBŠ˜B.·7B‰"]B®?ÈCäóCgÙCwÒC ]fBÓ@ÖB|á¾Bt§B^zB ¼B±d—B¯a°BŸ4ÕB¯eˆB¤1B—ÜŒBkKÕBmTBHq½B\ØÍBþ÷BZyB‚®rB‚‡Bp¾B½C$áœC/wvC.gC+0‚Cm#BŸ—cBUBkQšBb/%B…ÊB£]@BÀܬBÉíÒBÍ–B¸ÒB§Â@B€Ì€tB„#yB}'ÖByÃ’BYôRBQ‹qBƒoªBå¼BPBm}DBBAýBF°šB\åB{ë}B™5°B{BŽÙÅB˜gëB‡•®Bk'B5”ÎBZµ–B¯ÏBÍ$ØBÿ—BdUB¦á:C]JC+eC(|­C!+×Cí™B•Ö½BLymBW.ÄBhÌ_BbA_B@ÌBm@B¥““BÁã'BÂÄ'B¸ƒ¤BÛùBˆÜ¢BU1BIÃ2BNoYBUvaB[°›B€ZEBŒeëB‘JÍB•54BŒl+B‚úÞBa¸ÕBe¤B€^™B¶¹xBÖˆBf\B|ÌBm»HB޳ŒB²iZB›¨^BÈ6–B«+þB‹µ¯BcqBAeOBe¢BbBdÓBdŒSBdûÜBm] B±¤BÔd^C*±®C1“ðC.§#C4?YCŸýBœâOB{ÄŠBeBBcà5Bpm©B6‘BØÔçB¦´¹BÈìQBºB£f’BrܼBpÿÐBNuˆBoï³Bq?GB²thC(CÝKC(–CÍ'CÁB «BHøºB6Ô‚BW9ÁBp9½BDưBƒÁ¡B±Ì#B±‘÷B·îÏB¿ŽB¢1pBƒ‰Bm^BL~BA®bBWò^BkÊ*BauðB’hBš`÷B£fBÌB’aÚBE–bB^ B]b¬BŶ¯BÜáBÔœžBövBá©ôBÚ˜XC(¹CIfC1Ž*C;ËC2¹ìCñCB…ðIBXh¤B[§hBfƒ5B^Û˜BR®BMmBid´B‡¹úB]’ÀB\›£BRVÌBb-˜B24B@ŽãBBn±B[BS¯ýB–<ßBŽñ‘BŠY›BLB–ABsfŒC |eCøC ãHCˆBá• Bl2{B`Å}B€UmBpggB£À¶BÄ^6B²å%BÅzÓB¿üBtGBE¶–B:uÓB-KB‚†|B|£ Ba†ÂBkDBRpEB‡³öBÑZ=C!œC0ÊœC,a‡C4¨FCƒ.B—dLBl“™BUh×BQPÅB^MÃB¡Ñ B»’KB±ËäBÉÛB´Ø.BŽÀHBdìòB[5tBT*“BcçiB]¹¯B¡½TC EÆC¬CmÛC#"CË Bœ (B4@BN¼1BaîšBx">BZîMBl ûB§ºB¤ŸOBº%ÞBÊÒB¹qBƒhrBk{BsÖ?BzÎÛBtL„B~b=Bnt]B~©eB“™%B—B“ï4BŽø BU…°Bo5¢B^dÖB¿|6B߇ŽBÍÈBò#÷Bê-þBÃiCëC?r†C@K—CI.ÔC9ëŸCÎB‡í§BPX±BN§ BtÛÈBYÅ/BwÏŽBKÄ”BK{Bf”üB9 \Bd’BRáºBTEB1ègBVɺBOó»Bxí Bmv…B‚¬wB‡È¢B}SB"\BMfBoB|L–BPL1B¢¼BâC 4ÅBì’}CB'BÙ^B¤-]BÁ\€Bö®wBó]mBô üC `Bþ.§BëOkBǾ¡B¼Î(B±K B™UiBzc*BDéÇBEÑB^&VBk±£BZ„ˆB];¹BžÚ9B¾5ÇB NüB|& BkÉáBŠUBŠë0B†örBwÓÁB…š¢B†n3BTñÌBeþ‚Bm YBQ BkëvBzzBnzÊBmB`ã°BV¢‡B^(8B‚B´íBÀjuB½oõBè¾B™ûB`Ì¿BY¬¶BGcõBZ¾ÀBAÊNB®‡$C ¿šC"-ãCx—Cy@CMÅBžúB=¯YBVu£Br‹BjyªBo•BmSxB£©åB®¸BÆ.B·nvB°«²B…ouBg?´BlBjñÛB~æBxÞEB‰ BŒ QB¾DBŽ}B‘[ÚB‹:%BURKBeÓHBhPÈBÉž³BνÁBÊÏýBÖ’Bá~´B´7cCXŸCQWåCI´!CLŸ÷C-ï¼BöùºB‹¯BpxB\7¬BHøÃB>¤ŠBc†ÓBb?æBH-áBqìdB[Æ6BQÉ}BhŽQBL"`BA»âBt5B[î™BØÎBh>BsÙ¨BˆõÜB•šcB©¸B£ðBb/ŽBd@fBh“ B½tÄBêžFCÑ’BöûBôGXBÇ×äB®ÎKBÔõ”BóÙ»Bø—BôæöC ÓSC¥BòÓ¶Bß;ÜBض¡B²ë-B™ŠB„¨kB3K½BQ¿ßBQèABVKB={lBTõBÓhB¬Ö(B‘Ê~Bu ûBb_ÐBy<°B€ªB®"B7£BŠÈ»B€:ÐBcœqBhÕøBob2B‚‡Bij±Bt}úBŽóBio}BbÑBZâÁBQÌBbÔßBwmB¢èìB´EŸB°ýB³rB¥¨ÄB‚sTBuº B6î Ba†BL öBY ÃBƒ©çB‘‰VBq‰ïBŒ0BdÎTB‡wuB[bÌBh¤BŒaB¾1BÑ£dBÔ(•B͹óBÕÉhBÂbC&, CP£þCJŠñC@10C5ïCö:BˆJ„Bg¢^BI3 B>¾ BPĈB3À«Bcì^B§dBpaÉBXµ9B-·zB{3øBNõBDÈFBrvyB^ ¸BR°BfÌçB€½YBE-B˜ÑÁB‡ƒöB—»dBk†„Bf^BmŠÝB·ïBç§êBøæTBîýÌBëî BÙ®…B›}hBËÝþBöþXCؤCCšCXëBóƒBìYZBê[¾Bà0Bž¿BŽúˆB{ðnBJÈÏBH—EB9- B-s6B;x BMb1B˜óaB¬.ƒB›o B€¾ Bk B{]BƒKuB;B•†B|Ú+B(YB€¡½BmøÿBê]B€LÔB}-£BlT¾B]kæBhK`BH/pBUnEBnMnB|чBxõBBNVëBn(ùBLå„B]WÀB~S?B°º^BËŽcB˽BÕŽBámpB¦¶:BW9B_8B†ì¿BƒþÀB‘B¤.¢Bž¹…B¦èµBx¾ BO¤‰Bj~BŽb\BqS—BvÝÛBzÇB‡\ÄBƒ—ÞBrfB‰…+BkO6B\€ÖBu'fBÈk C9CÂWCî0C ìSBí?dBu¥[BAîîBEö¨Bu¥\B¤¸B§lpB´inB°âB¹ùòBŸBB[@¥Be™Bj-ÊBÁ1BBjBP™ºBbF·BˆoIBaB»-£C=¤C,dC)ʳC/5·CyBƒeÞB\ŽLB„¬BSœâB}a*B—þsB³ãKB±ŒBÄ`qB²wÖB‹‹pB}@xBx…åBg…Bd‰BVÈkB²îCÉýC!îsC&ÃC·ÈC·B—…ÇBFf2Bw>BA½äBhËñBZtB–[B­ž~B¬þeB¢¶B¨‰‰B¥çBzìQBc„ýB@ǽBI½B6d!BQÞºB‹®ˆBž²B…)ÊBŒPŽBƒ­B‘›[BoIzB€•­BŽˆB¬—þBÝŠ@BÂöçBê`ÇB¾¯¶BÎÛ CõCZM©CBÚOCE<*C4æ¯C ÉöBq „BT?aB;6¾BaÏ|BUÓ9BC‘3BS(‰BoSBi`BAÈxB4„BS=°BMDØB]ôóBH¸mBCÀPBTÅÿBdë£B˜;B£-çBŽ›BŒ~´BpB~ ZB_4.BiÖJB´gýBÒP³B÷£{B÷ÚIC±ZBÞH'BAOB©(0BÞ©¿Bõ‚ÆBö‡YC ƒ BêØBç|áBåB°BÊûÈB¢%Bˆã'Be€­BE~wBQêDBSkBP™ºBMØìBCn•BœNÛB¨ÀÖB¡fÍB†A¶Bje3B‡ ¹B†›lBƒwÚB‰4B€B B›ŽõB|QyB[¦”BeÛBlãB‚G±BmKØBfB^ŒCBŠDBaFÄBw××B`ÍßBx?xBVüBy• BlÈBS(aB{dzB´z˜B×Ñ!BÔ.XBÎÖÅB·äB JtBH`ÞBU~B†#ÂBŸB¥äB¥˜$B‹=B§4¤Bl BoާBbðÚBƒ‡BhÔŠBm‰XB†«ÑBu“þBsŠ×Bc½¨By0Bk˜;BWýùB€„WBÖ@\Cl9CÖ»C BCuwBæW”BliØBa˜ŸB`äBv–¥B¦Ä$B°CbBÉåÞB¿ÒB±âIBœ’BKiÊBd¨FB_TÑBwjB^[Bfí Bl]XB†'›BkdOBÄ•C4z½CüC0¾C>§ŠC B(-BX« BwÏ%B\ÕeBo׺BªB•GB¶ýB´Ê„B´ÃNB§=B[­=BuðMB@ÀôB{¥ÖBtCtBºùC C"÷VC$ŸCŒªC ÍBB3íNBsàjBA4UBbýZB^TB„á¥B½þHB»ÒƒB£|=BµâB§—®B`žŸBjèEBn3‰Bc%¼BVayBa÷ÐB–Ü Bˆ¡½B…TŒB§Á‚BŽQüB~ËBugÃBPƒB|ÍB­ÅhBÙ BÆ+‹BÑækBÑ_ÎB©9óC3CRä‰CC¢CS>pCGõ¿Cƒ’B’¾­BSgBZŸ BYŒB^ÑB:¬:BA¾ËBJжB\sQBX?\BQ2ŽB`B‡RƒBŸBȪ:B¾» B¶úßBÂF6B³#´BjÆ-Bw–ïBk_B™&ÕB›j£B˜kÐBwëB¨«Bƒ€Bd&BC%BrçBo™¿B;KfBdABTœBnà,BlÐJBa›B|¢GBeBŠ£ðBÈ|—CäC ×ÇC 0tC [Bðò½B€5FBE¥dBXò¹Bxï*B¡YB¿¬XB´Ú)B¾w6B³­3B’ž=BSqBqB€÷üBpÑIB{ÖnBkwB\ÓþBiB­B~<ÚBËt4C2R´C*\C-‘¤C&÷CxB—G‚BoûÓBYŽ~Bqÿ5Bt}«B»IFBÉÐúB·ÙwBšÞ¼B°—LBº&hBpŠ!Bp[BP{lBkkB^×_B¢0ÅC˜œC$ÀpC(í/C·ØC žB™"BP ìBZ*CBpí,BNB^·¥B‚ÅBªÝpB®´›B©ùB·½•B“ÃBYöWB~tŸBnq˜BcwüBP_ŠB]ÅVBy×ÛBf0B+B’óVB‡BˆóºBoÞûBKù”ByòÈB¼ˆBÌ¿ïBÁåBÎøBÒsB»ÙC¼‹CKôxCD(ÍCI3çCEÇ´Co B˜4 BRé‰Bcj†BTßuBaÝiBF©BbÒšBsΫB}Ä©B^l¥BaõsBJyíBW¶aBMa2BRõBmÓçBWPuBu|yB—¾BB¬)B††BÁB…CB` 8B[°¥By>B¨pIBãSºC8ÐCÉÁCñiB¿\ŠB©ÕùB¬4´BÑw$Bù'²CfCŽÜBú²B߸§BÕ©BÂ#˜BžoB“¢üBžöBˆÏ[B„ÄCB‹Ð–Bd4ÈBFëBn^³B»±IBÕ-ÊC”wBõIõBï»_BÈ tB­NšBÈZ$Bá@¥Bò»'Bã CâwCÆ—BÕ7âBÉÚÂBº2BŸ˜ÿB‡’ˆBo”PBUÁBz1B]a¬BM$óBMêBjAÑB™‹B§ÖfBšï\B†#)B‰BŠ*!B‚K5By?B¡%;BÈZBcOBf¸ABm©:B^¾wBü)B% %BT¹ÁBNˆ®Bˆ+¯B‡‚BoxBK¯xBnãïBiy{B^FˆBOß7BO¬]BBS BfLËBÀBÀÃyB¹)cBÉDBÃŽ,Bˆž¶BU(BeàB9íBŸ)ÙB3B cBžâ7B†3{B‚E·B]µ&B‰®XBrhBL£íB6,ûB`ïBmœKBbº¹Bf˜$BT¯ŠBi©·BeBÌBjã.B¼ÚPC Cœ´C 9(Cð{BׯBZ’DBP”Beé$Bq¨ÔB¥{B©¨bB¾èFB¹ÔÂBÔBƒlmBCyBFþ½BU:öBP B†Ó”BrÝ|Bl;hBPŒãBg1ýBÏ’!C7,ÐC83C2ÌŸC+~oC'™B§<1BJÇB^¢¦BRûBV— B“•êB¬ÅBÈ——BÂSÀB½wB®ÝBq­¤BNäB^ôB,gB€#B¦6CêzC~ŠC eC%UÁC²B¤lBZ;BIö[BSwBL?îBcë‡BÀ«B JËB¦ÉJB®ÞÿB«]fB¡y­ByÝÉB[ó&BHÝ–BPE¼BC·QBTBãBzÆyB‰KNB]’ˆBŽˆ¦B±¤B…|BEþBT”Bhê_B¹ã©B¶ö$BÔ_îBÙ„ÁBÊBË<„C…ßCG>ûCG× CKÞeC@ ËC‚PBŠBR»Ba·BXÎBK2³B_cêBXØBaújBHÇyBGyBc×VB^£œBMB=^SBS(1BG_ÛBK©B`ü‘B‹>ÓBŒI,B—GBk¡B‚HšBY*§BA¡ªBf}BË1ðBäKáCßZƒBo—JBE÷ŒB>äúB“n¡BÄ;bBÊQBµ:‡B³ B­­×BY6vB…šABZ70BTx B[âB¬±pCµÐC%ÆÍCxÿC(ZæC k5B£Ù€Bs ÞBZ âBPÑmB`w/BV-ŠBr,ÔB©„ñBªµDB±B›rŒB›GB“–ˆB\MÎBbñÍBK‚ÇBI5[BsRB„÷B‘$“B“¤yBŽBBšGB‡ì{B7yñBW$§BnNrBÃ>€BÉ€æBèuBÝÀŠBà\ÏBÅ—ñCÄCT{CPþzCNlÉC1ž†CúgB)œBO´ÐB?ÊÉBGïB3Ò^BX’ÿBX·‰B_BdÚCBLû³B0ÓB8Ð@BprBWïŠBDoBMnB1kóBbƇBœO³B•§ÛB‰w¬BŽ„ðB‹@gBS¹¨BS™íBeX8Bº2¤BéÿCÈNCþBôjíBЂ*B«³˜BßY¬BßÊ-BÙ·BÿkECžœCàBØ:šBÅ¢ BÕQäBœ+¤B–*BZu°BUmBBî¡B`,/BGªB/ÒUBJœB˜JÉB¦üB}¤6BdY•Bq¨»B€EèBdDzBh‰UBm ŽB„ˆØBl×ÈBXÛÌB]ß—BCE$BNUBk éBL$@Be†ÝBp¸ÛBm „BF”_B\(BY|Bd©9BL¥ÈBS£:BB‹öBUcBT\hB³‘uB¸_BÀüB¹ú%BÒ…ÉB­œÅBTñ«Bo¦B’¯…B›>BŽ…Bš¸?Bœ¡/B“ˆÓBn8B_ÓB¯H§B¦§ Bœ5úBœNBp,ÍBtþBplDBDÉ#BcTYB‡ß½Bt-ÍBeã'B`†B®A1C-èhC, ÷C2uÉC-³…CUB†D3Ba22Bi„õBa]wB2¡B·èBÅOBÚe¥B¿]xB¶JáB¬0YB`'ÙBƒ¤Be_mB\÷‚B{”üB·b5C0 Cì C®TC'lËC_EBŒ>÷BmrºB[dB=ÌBllBo¼MB‡ÞÇB­‹òB²±ºB±.¶B±Ê{B£‹ÛB—ºB‚˽BX­oB[b³BC˜UBpT:B€àeBŠþKB¦ÏmB‘þ™B•µBy_BM~ðB[uîB…W©B½šBÙƒ¯BõzRBÙbƒBíÏÓBÍ$ÞC1ÄÝCKºHCM†"CBÐËC:•YC ^•B|Ð^B@£šB?-Bp×B5ÌœBJtB\xB€ B\ÒøBPò˜B£µBH#ÊBRÙ!BZGBWeBm áB\©Bw'VBYQB 2*B‘3¶B”ðìBƒÖBgʧBu°BjÎB£OÂBáæËC цCÙßBéãûBÃRîB”ÏÀBňPBÜÛBù‹ªCsêCƒÕCBéBÑrÉBÚù¸BÓ¼×B¶ëB‰(BZYQBC.B>éB8G9B>²}B0ô:Bkï:B“Œ3B™ú4B•J×BiZÁB‚8}Bp3½B‰7_BgÎ|ByÆFB‡ñBŠÿ!BW?xBe÷`BTNBh÷íBl;¤Br}BaüfBNuBa’ÛBqÛÕB^ç³BeúBW9·BQF B\BWö»BRBf B¤}BÄϵBÉB¾0BÝÃBŸ’{BtAÚBZpABŠq[B•:äB”ëB”pBœî„B„Ø«BŽ/BLѹBcH¬BSüVBêÇB‚UgBy˜2BAõìBnÈBxª²BvôBr/BaÓ˜B\'BNÒ9Bo[Bq¢³B„wBSBB\f-B³Ð2C5‹åC&› C1ð”C'+"C ;ôB–¦ZBQåBJB‚íSBxœFB’Ü)B­›BBÉžàB³ØÚBÀµ&B˜¼BrÃ)Biø5By42BkjfBƒìœB¸”bC ¢CJC"ª~ChC BŠfÈBYKòBGìØBMœBq BMVjB”vBB³QÁBŸ,B·øžB³ñ^B¡àbBtª©Bg¡BRÓ9B]EAB.¡BCÉ;Bd¼ÉBŽ’B‹<>BŠtB„Bj±ÈBoÍxB{ÝìBˆO4B²BÙЉBÞf’BÙÀBéhZB¿¸DC'iàC>ªüCD‚,CNåÈCHÆ{CæVB|½öBJJœBXrBqJ=BQ `BUº}BYj·B`èûBa‡¢BrJøBg’¿B=ˆEB9gŒBHÞ0BV®BS}jB\²#Bj¬ùBÙB†ÜB%3B¯ÎBŠëôBzEB^KÁBb=]B¤úBú—ÜBöƒ'Bú¿ÄBåÑ›BÊ—nB‰ýùB¸;B×é…Bí‹|BìméCȃBñ1žB¾ÉSBÚÒ¶BØÔBÐVBmÈB~‡¨BJ|œBA…lBRB=#PB=écBKFˆB“užB•¦pB™­hB{àyBc ÈB]QÅB’{1B‡õnB7aB‚'Bе7Bf¤ùBoãBX˪Bi0wB€?HBe.ÆBQÔðBOé®BsðB€àõBlNÂBsÀMBSè~B>3$BfUVBlé=ByúùBgôËB¢ò9BÕjBÌ8SBîËØBÍ\AB¢ø×Bv-‰Bj>½Bé†B¦ÂBŠn*B™f^B¡ÛCB’÷B‰1VB[Í¢Bvš1Bf©oB„}ùB~œ0B`YBQ7BVJBx˺BzÙ°BV®BkKB{õB»ÝkCÔ:CžèC0QCNGBÛ]WB‰QŒB\§æBzpâBi½B’ CVºnCP\%C B‹ð8BZ’?BgàBbõ\BH#BIMBd0¾BWr@BK\ýBdL¡Bs ÆBAØB: BH£àB?ØBYZ¶BQVËBkB }CB˜SÙB’b7Bl¬ÚBy¬ºBTÄ­B^kÒB^A„B¹9ðBúÅ9C2Bù©’BôŒqBÖ&ºB¤ŠÃB˽ZBÝ@Bê*FBññ"CCeBÑnBÉ3B° BµÞÏB Ö°ByNBPÈ|B4BGº9B?hlBK.ÖB-ðPB‘õBŸAXBœg,BmÚBX.¿B‚}FB‘•B…×BŠ4ÜBŠØîBvÍÃBYlVBZJðB`·BW¡³Bvº’BlzBBúìBMïB¾ÐBlïnBC@÷BiÅBGŸºBrBpÞäBW¨kBdBˆQGB¦øBܶŒB½eäBη«BÆÊBšÇB\BwQ{BžŸ®B©‹ÓBŠ]B‹žÊB¥¹ñB¦‚çBju/Bs+òBgÑ9B\SâBs#BvLèBjÛBZŠB9ý…BHvRB‚}ÆBzÂ@Bn4ÌB€6šB¹ŽÛCÕ¶CMœCÚrÝBV FBZvöBX¼¨BE{ÓB~þÝBŒoìB€É=B•¿’BŽÎBy3BOw–BN¥øB|U"BÐ BáÖ^Bã>ñBÜýBÔ‘CB²—¯C%æCLžØC= àCKýŒCS3ðC Ä>B‰f…Bp¬‡B>ðÔBRòîBU³¼B?Ù…BUrZBY|÷B\ÒÏBpïÖBo¤Bh¯BF B=¦BO`‚BZ>;B_'ìBpŠßBŽäIB¢ê·B—ð%B‡¯”B‡a²Br¹‡BIHåBrdéBÄ£BçŽNBüÉcB÷K$BøÂ$BƧB£s¼BÕg3BÞÝËBî{ÜC²™CY-BôBÛïPBÂÇèB¾HxB«ó°BšÇB[öBjk‘BBߎBKTïBG¿¡B]V‰BEúBš)B•>BÿØB‡múBc&gB‰ „BžyÞB€ý“B¡87BI¨B~!ÂBxk€Bs2ïBgä'BL >Bk°Bk¤šBPÅBOYB…ZæBg OBA>áBL…úB[<ìBŒ^Bm*'BHý.B+fBˆó BÀãB¼ÃBÚnOBÈå9B®usB”¨.BWÑéBoôB“dB£¨B›‰;BåB­ïBœòÅBTðjBdsB€q1BebûBs!>B‰­!Bf+ñBkíúB~5ÅBmÕzB„ŽBj¿B† »Bru BÑã#C«ÅCCôàC¤„BÐLBŒ€4BWB_]¤BmBŸv B¾ç‰B¸bOBÎ B©¯WB¥§œBE±‹BWˆÖBt B`I8Bo}ƒB|ÐBq-?BJè'BU¥/BÚ-»C0{:C0£_C-vdC) ŒC⯄CT©8CDAC.B`­7B¢2BJ1BFžBX%BO¿“BH»BEb²BoMpBLÈìBì…Bt,ŒBG&žBDz÷B5F«B>׳BN·&BwZB…Ä+BžØÔBfùBûB’^BiS¢BT„¹B_|hB±þ½BäÔ*C$ÆBö™Bñê£B¾—@B±ºóBÂGzBÜxEBð½3C¤mCôjC†Bü­pB½,ÀB¸"ÙBµÎ7B‡U"ByM BZ~‡BKà;BJYØBNÚºBU·tBfŸTB2ûBŒÛ˜Bˆx B‡RêBbøèBŽv¼BŽëQB€ÔB“ŒÃBkȪB{‘B‰¹ñBhÔ—BaMðBr8Baâ¨BP¸3Bgæ£Bd4Bj½îBYYçBR#ÙBcôLBE“¥BQeBXb[BCøüB5=°eBî`9BMìåBe’BLgzBSS–Bm¶`BElðBLèRBK´BuèrBMP*Bj¸þBiä~BU¿ÆB\ BH®—BTnBV«ZB æBŒBŸøBëIB… ÕB‰¹ñBHïúBZêÙBWÏ©BÀ‹Bï8CO³Bë':BüëÇB¼' B»þ©B¿ŠÕBêÞ&Bâ&èCªCÞnCzýC£”BÆ 6B¾`ÂB»VßB†à$BofBVéÚBPYB>ùûBTóîBSâÛB^÷cBŸ 3BˆáªB’‰ÉBXœBn²B‘K¸B‘³ÒB‘c9B•·nBkm°Bt0BlÒžBkVB\ÿ©BvQöBN:QBSLBb¢»BiøBTÕBNÎB[…ŸBVNùBB©VBCV BK_0B>Ø”BmOZBlkôB®zÅB̧ BÀò½BÀ›îBÅÃ)B‘8;BaQZBt#œB“ Bv\×BuAB«A™BžMCB@cBmÔ;BMÉ]BN-]BpBE˜ABVœBnI‰BOˆzBo£°BvtBt‚ÍBcnBcI3Bu=WBÊ•ÅC ®ºCçC$C†(BÚÊÍBÐùBC€®BI´-BfcB˜êkB¯¼¶B¹9BºïB§¶ßBZÂBoßMBé~BrÔB]´[BNì¶BW˜åBqbÎBŠnBnÊaBÆ­ÆCFWC3#3C1îŒC%ñCòÙB– ØBC—ÁBNMBpúõBq DB›|—B¢¾BÄ’ÕB¸6kBÁ‚³B¡åBp1BE›#Bnb‰BP7zBw™/B¸0¦C¤ùCy­CÉwC:GÍC ¾ÕB{B-ÐÅBKñBqiˆBAh$BT)B|ñsB±g'B°“B¯e6B¡Æ®B›äêB^cZBf½ÏB}_ByÁB<*ÍBTm\Bv`¯BƒžBuOœB"ýBµ$B_4øB]2ŒB\íQBoëÍBÆ^íBÅÊ_BÓÃÄBà™UBÑÎSB¶ÓCý C;V;CD£¸C:ŒCAœ=C–nB‰HBXùB[_=BE)®BnïáB3eBy•×Bdi¨Bg’OBPŸSBNÁqBQÕæBFBg'”B>B_BI™@Bp÷BevãB‹|B™B”8B=èB„-LBKÞBS€ÓBhP²BÃÐBæùŠBúwoBð +CjåBÅ?èB£9[BÄòüBùšÂBÑáBäšÐC,%B×­°BÖêBÎŽ˜BÁ.B¸¹ªBmÇ»BY >BM·B]¡ Bd²BVuBK̶B_Y‚B©ÒYBˆ™B—ÝìBNa%BwòÓBŠãBŽg7B”:½BŒ—MB€Û B€o4BTÝBji'BO½pBw,6BdÄ*B…îKBnjØBL²UB. ¸BIskBh:»BPäõBLM–B[²BTlËBT„ÈBLëçBƒwéB¹BšûüB¢¥ÿB¶¦-B¸_ B·šhB”¦[Bf€ÀBN‹Ba BW¤êBmoBa¬7BeòBLÔ§BŠŠÝBÕD$C+õÓC.ÉÝC$(·C%ʾCßBÉ%BUŒ`BWE¹BuO BchBŸâOB³ B¹ù#BçtBÓg7B˜­šB‚ôB(,BYÀVBYé¯Br«*B¹¡£CWtC èC KC,±Cò5B‡­°B9åŒBRzÍBRòB+°BNšBfzB \èB¨º>BƬ’B¨øCBœñmBsã«B]¡šBh„"Bn¬B@ûøB^·B{GB¢™RBª@tB˜²BÑB‡i>Bi—¾BO‹}BhŸªB]í6BvŽBdx5Bˆe*BcÕµBbÊfBr¿÷B‡fBUéKB}ÿBÈýC˜¼CEˆC¤FC ïëBÛBheBmõ Br7mBq4ÆBµ!B®¸3Bªž¯B¸}(B²CãB†ù´BUä|B?ZNBgöoBHá¹BhšÛBQ´_BMÿVBDPB†Ô5Bêà)C3êÀC20C+‹øC1òClÇB‰ù~Boð½B<Þ»B€"EB^®zBžKfBÈñ)BËÛPBëBÏ·KB™:JBŒ±)Bo%ÚBF›Bg+Bp!ÆBÎ5BÚðhB²¦ùBsŸ"BmJB„™B—ænB•@ŒB¨[âB|·B™>©BŠFñB„d±B[;áBgNABjÕ#B€UBX§NBl¿…BoòÀBH”äBpqBFÇBnTTBno@B×SäCa C¢ÚCS C }BÞdŠBj[üB` ¯B„á7Bh~B 2òBµ¤B¼d ÕC8Õ/CIB”1eBD–BF‘‚BD‰QB2ˆ­B\B`BxmæBWu‰BeûËBPÅBdjÕBP mB0…BCB>!BN!BNT BL˜ÆBz×5B›'B‘~ Bh˜BƒdíBrA"B>g!BM¨BÆ æBð¤¤BäLŽBåZ¿BþE”BÔó=B¶÷ÇBÃâBËŠB×ýBÌ‚ªC óBþFBÏ"ÇBÈ6«BÁIBµ×PB}é¾Bh‰£BO÷BaZ9Be?UBUMBb`B9oB†uB¤NBš B}Õ BOZnBx¿B‘á B¨¹BKÌB‘w‚BàÞBtôBLrÔBaUB\üBXÚ¼BXY4B`XB8¼áB~#¸BPi÷BZÜB?§#BC4»BRèBZÅB8‘´BVÿÊBˆ´B·0ÀB»%ùBÏäòBÑBBáïfB¨Ö!Bx\ÛBkêSB JB B¢aºBµÐB—ªwB‘õäBx'B†—ÎBÛ¯Bi¨B€GvB[¼B_T7Bzp–BY ‘BDB^àÕBYNßB_ì#Bs¯½Bß’˜CÐCo5CfÎC 01BíáBzâ Bm\„B‚TB‡ÓB’ÍÂB¯>BÌm¤BÀhºB¦ðB¢‰BGŠÏBe­6Biß?BƒÐ¿BemÀBwð3Bkt BfJçBr¬ Bà¬ÍC6“C>â C.ÈæCçíCh!B…b1BE²BAŽBEXOBnâæB¥¡BÍÆZBÍýBÂVzBªù>BžH±BX½®BMªB@½wBc‚hBS õBÑöwC%W×C­•C<ŸC!M:C møB¬¹ÌBU0B5ƾB2¢æBkêRB^k†B ¶B§ pB­ 4B©;B´A2B¦ÒCBƒI,Bb6­BUêBDÒ¨BT ÍBhL]B’sÛB‡I5B*ƒBšÁB‹ ¿Bp¾BYøBWtB‹Ë B¼/öBÛ@BÐ3Bäû¯BãáôBÆHC!IŸCTfíC7LñC=7\C;>ËCvÆB‘%¸BQGBGRB9­ÈB(õB`üBm4!BmšBZ‡B]úBjÒ„B^¿.BK»BA•B+Æ,BDdB67>B\½¸B…B‚9B[ÌBŽšÃB‰\ðBw—½BX°8B_SAB«¯tBé`3BýhBëBüÒBÉ¡LBª‚BɺMBÜsBÒDÕBßàzC ªBó£™Bä¶tB¾" B¸Ã…B¯2B…sBj§?B^BU:¥BVL¯BGqÏBP¡ºBPãBžÇ›B˜í]B|™BnB^Ba+ÕB¯BŒÆ:B‹kÚB{|gB–B[pÇBw~ŒB_ BxDBcÃÍBsôBceÅB^ÕBG SBgF×BclB^k’B0VªBWö_BFŽ‚BH-BXd·BféÅBp¥B±zøBÁ!ËBÄÊ•B´NÁBÇ‘B¡bBví¼B}´XB…”IBšdB¹'B¶Û£B’â B›qÝBf"´BL§¥BvcFBz©€B:ÓBB•ÅBTÐB„gB_ÆÓBjDfBQì®BLlBl±ŒBx/ÙBЂrC ‘C+ÂCR¶CŠ­BÝàBz&»BqõŸB|GìB‰uB®™8B±YBÁiB»ï'BPÕB«a/Bc˜BNR‘BLÅtBt¡FB9×PBck„BpÛCÖŒBÚ˜+B¤ÖªBÄAêB×Ú»BåißBÕ¦ÊCTBôTBå4‚BÅmêB·’TB¬{ßB…‚BfyB\œ@BE—õBO¾BH„þB6èZB`+ÉB­"­B¨þqB’iBY–LBwÔhB˜%ŒB‹ÁBrQB‹¶íBvè_BULB„vQBhé¥BtZBtRSBz©ÇBn˜:Bi¡B`ç7B[_Br>ÅBc *Bd4‡B\§(BeíäBL/*BTkBxmíBZèB©0BÙüdBÃSòB¢áãBÒXÑB‘®ˆB[aBzöÈB 9B‹ïÜB¹©šB¤ATB³Z8B¢úãBj‡BtBh,7Bk™B…ÁBb¸Bt#¬Br¦çBgäBn­™Bm™¢B‚ã†B®ßB_ÙtBÑÈCz.C ÊC ’eC ÅÒBåöëB|c4BLù¼BjøBˆwâB¨VÿB›ÚB¨‚DB»w#B©[“B™§ßBmj…Br2ŽBO‡”Bf$ýB]ôB_¦~BtæÜBVÃBlòBÓæäC'ù‡C!ŸÐC+vC!CüC¦ëB†¦€Bm ABt4ûB]'B|ÑÇB™ÌäB³·}BÆ„B´Ç›B³Ó`B£ÎlBÝBUbBb–iBr¿çBCÞB¦éC¹»C)øÔC –ûC](Bþ{ÓBˆÎBcGVBd:šBw-ŽBV'B=å+B€ÙhB©ìB°ûùB¼~B¦~âB¸×‚B[ì¦B_\tBEîÚBI.•BBeB©Bh1üBŽ=HB¥c¶B£”B‘6ÒBvËzBf]¸BvNzBŽÜkBÊÒaB¼Y”BÅiIB÷/BÕ—BÁ§ECCG¨TCDÊêC/GõC*GBþÚBŠþ„Bo ûBw¡BLxãB_J/B8JB0‰BnggB]"CBWvWB;M¶BI=BXÉÄB=âHBpŒrBc ÌBpEIB\«þBƒxB‡´6B‹À¿B„ˆ2B€•ŸB€ŽhB^{tBXºB¹OBàMâBù~èBó8.Bã·qBË ¡B¡í,B±õ~BÚírBð½‘BࡉC }ùCç¢B̦BÛÉ£B·ÝýB®H¡Bk”UB]_ÍBJžÚBRQ B>Þ5B<¿BL•B^v¥B˜€†B¥,B›IèB„ÁB|žJB‘ˆÖB…¹B€ –BŒÅTB’B—ΊBtŒƒBtwgBZbSBlrBo–&BwÔBbŽBeŸÕB\‘Bk/¶BO×IB]P¥BY| B| ’BZÃC#ŵCˆB„qÞBGÔøBW“ºBaëÌB…lB™#B¶#óBËyôB®æB¸tAB¨ÿB\¦ÂBB–©B\B`~jBVþ°BºÅ C>³C)ýÅCª{CìCB-B‹e0BgÉ·BO8OB_ LBL.mB>Õ!B‚#÷B²ÏŒB­ŠþB¿”B§:,B¯ÉþB$2Bl*ÞB? BKñÙBEПBQÊöB„ÇìB‚Bò’B–#©BƒYBM×mBR•ØBt\ðB“¹B²VeB¼ecBÚõãBÚ‰;BãíBàè{C?KCB€ÁC@¬>C>Ö‰C3dúBêç›B„BÀB_h‡Bc\B\è%BdQBBJpFBhÞ£BX²CBN¢OB`v¸B_ÙþBBf2B’ÝÝB«¶mB«öÚB¨À¼BµQB´hbB”JJB[LBa1ŸBw8BeM‹BWúB}ÌBXÂBZh BŽJ·BÒ2SC&êC0üöC2ÿŸC'`ßC&šB—š]BjIB\1ÑB-ÏB‚EÌB¡ÉBÓ²ðBÈwB»¯×BÊ÷^B¬PÁBx>‘Bfj(BcjÚBj–lB…øêBµÝuC'òC$?1C R%C 8CK©BŠ2¤BZ“eBL¯¢B@ËiBkPBOÃ"B}¶B¯TB™ãðB§sBÊüBª¶¨Bz‘ÂBtŸ¦BY‹ïBAx}B_BJÅABƒÙ*B’Bƒ>B‹µ¨BgÔ¨BI ÞB3ØBYdƒB…=B¬Î·BÌùÊBÔYÃBØÓoBÖ]&BËp C!&¥CF.mCGoWCDNC:i²Bõ™IBt+LB<¦ÖBGèBWÜ4BaÞ²BSÜ+BT+ùBX‚BG*-BoÿBk3'BS©5BAXÂB;Š9BNÿðBWAeBHéJBoÔºB”jBnlB~í#B’ã¢B‰®BW%ƒBB ‡Bp×aB¨‚·BïÑõC]ˆBÿZBßBÐ…õB©ëKBËÛ@Bé$YBØfMCÖPC jµBðNBã˜(BÌØžBÕ4„B·ÃBŠqŸBNgBc«FBB`8Bs«jB]¾ïBGGüBK¤TBæ‰BšÄ’B4ªBg!BRœjBƒUBl‚yB”¦¯BŒxšBZBv½áBHålBzà1BjNLBX›™Bk%9BjNKB€§Boù BoúB}I%Bx™ÈBlM´B^ÑwBW±{B\ÑBSºXBb_BrþB­|ABÃà·BÖ¯VBà|BÅðB«L/BgnÀB\išB„¾B©%´B.B«”ÈBƧB”¾¤B…qXB|òmB€í”BƒBq:oB€EÊBS•þBsj Be5…BSMàBg ¬BvvÐBL»0BˆzDBÎ×®C ³ÇC˜œC ûìCÎíBè’4Bk}4BX±®BAúOBu QBœ3JBÉïB¾{B¹C¨B¼ ÀB‹9¡BNhþB[ÍÕB=’mBUjBBsã3BgƒçBvãwBmjyBglÓBÔzòC(ÔþC+ËC8^$C \÷C÷;BŒåBgRÝBW.B%âB…?ÓB¥?¡BßêWB®˜iB¸9ÊBÏMóB mûBu`îB‚’@B5‡ÈBltRBvîB¬VˆCqÈCS CÚnC TCÆuB O±BY_BIºìB==B~Ë€BO½aB“LBºº,B¦™ÈB«oÃB·£B¢#zBAéB…Á¢BWõ8B>§ZB{(¼Biù¶B„iâB‚FÅB”WÂBtQBjƒ5Bm 4B= B^–TBl$ƒBÂÒHBÒ¦2B»âÏBÊþBÀ¨qB½²ÀC-½CN‡rCKÐúC<6GC8kC ìŒBeGÊBQ(×BK!’B_2B]ïüBgn¿B}÷BGO±BGÖNBj„+Bj¬BAGwB3´yB8°nBFËBJ¿BD!EBu, BcùB“¬šB¡( B™åÞB„þìBZÝsBT0ÌB[ÏÁB­jBìÚBÿ0Bê©ÇBú­ÄBÍîB¢•lB×ÄÅBðGÁBÐð7Bé‡eC ðBðEÕBß :B×wÙBßðBÀJ°Bˆð B\N­Bm×!B3äBY|BSõ/BiœpBY_B—hBœaáB’¥œBcBqA°B‡–)B‘‹ B•–TB‚ýB‘ê‚B€ —BT÷xBf1GBXލBx8kBcò‹BjrKBŠw B|arB`O×Byv÷Bt‡QBcìÉBvÆ BdŠ%B\q¦B÷üBk¡~BnÑB»Ð%B¿¸äBÒ©˜Bƃ%BÐÁABªŠ–BJ8:B_,B˜uÁB¨ñïBŠíÒB§ÆæB£ˆB•PòBƒ¯úBy9ÚBoäoBr>[BnvBU››B€É1BiRµBƒ¢ B[\­BcŽÀBz#B[VèB‹Þ4BÊ_›CžICyCÒ’CÞœBß»aBs‘ÇB\ £BXãBU¾8B›nÏBÏ>·BÈB´¬UB¿¸°BаHBhóƒBQÞàBNùˆBJ†B€8{B‡G5BxT BSÄsBn’ïBߺkC+®¢C0©cC0+mC)¿qCëNBŠ'CB|7;Bn BA*ìBpÅnBœÿÅB²œrBÎäBľ¾B õBœ]ÀB|§¼B€ìÅB0-æB_KgBlÏB ?C”ûCS`C!$RCµC2³B–{üBRy®BiÀRBDƒ§BX_KBOL8B˜k-B¦gðB¾”bB§ÛB§myBšQ¶BgÈ{Btt³B?2B_a…Ba {B_»èBŠñBTBoïBˆmëB~·BŠÛBbi{Bx}cBh½«BªtBÁ¼BµeèBнiBÝIçB‹HC2ÙCL#DCF5C8ÄÝC2OûCFôB€ˆIBqº B[ÒòBRįBg]BuÓ©B‰ÔBWnéB?BwBMDþBKOB7Ý3BLMBRÕBO ôBOÚ‡BHͺBr¨B“øBAGB›ÐãB{sBˆM:BS–LBQ³›BbÆ¿BÏ´ýBéuÂBõ’¶CUÉBý:ÍBÉ)‚BxrBÂ0kB×¥¬BôÀBø5C ø#CÓ BðBÚÖBÎÚBª·ÇBc¯pBM®ÃBeÈðBd»µBBvBWÍ$BfðBSqÂBØ#B¢ëÄB“Ï—B€áBjBhíÓB‘œÚBmð©B‡¾ B†ÜBw× Bc«©BYç=BvG…BgÖœBK´BkUÐBvÿ½BoŸxBj2Bf×cBI.B_#BHþBeÓ]B<\B@B[6BvÒ¥B­èBÔNuB½#‡BÈ$þB½áB™uBo JB|"3B™hB¯ö%BšµÆB±tB²e³BŒùpByÄoB„mvB„«{Bh¨£BwvBO;Bwú¾B^+B‚ÃB`ÍBz2 BXIMBið…BwRyBãÍDC‰yCôäC¡CãwBÓ6¤B††{BmSÔB_’®B|ÏGB—³BÓªýB˵~B¼2BŸ'ÀB€âAB„t1BL"»B‚ŠBvÈBrûæB_?þBvúBqEqBƒèÅBã¶«C$Î’C-ÄC$ÏÆC) –C¬B¤bBz…³Bb%UBqá5BXî¯B­õ¥BËt–BÕŠPBÓBÐÈ BŽÅ BV4œBhá^Baï}B^%Bk¤BºG|Cv»C€ÍC õ`BQ{ýBT°YBN’B^?BWæ¡Bg¾bB¨y!BѨvB½”¼BÅÝïB·È§BŒýàBp“ÆB†D>B™ÞBŸ˜]B—"€B˜4ŠB¥uRB—B€ZNB¤BzWÄBdÑ4Br¡¼BO¶UB|cÎBI®Brˆ¼Bw}öBj„ÑBvRëBjì©BsÝBù«ëC—¨CéÇC3ÊCNBÛæMB ÁBlÑGBeáRBa›B“ÐB±ñwB´`BŸ€RB·”»BgBm«‹BW+ñBv¢»BY}7BsHB0a3BqámB:XBsšÅBØvúC!=*C0»ûC!Ò4C)—ŸC ­³B 6 BSfBtp;B"°Bz‘vB¼~Bκ2B¸íìBÊÔBÐ6÷B¡4ÜBcžyBO½Bg BLqÌBieQB¹A“C:CùÙC#C1ŠCÓjB›Ÿ‰B:ÀBk+)BfB\×ÝBDdCB{ëB«BäB¾Ï5B¾UBŸ…!BµBƒ&B^sgB8«OB…ÅRBNðABeôBƒ¸SB—›§B… ¾B’ÁBz:Bƒ*B]*ŽBf¢–B?BÌ]cBÈäBÓKlBÐ -BÙ#BÙ>C/ÝCHºÁCQÒ¢CQ»CGÏ.C ¼$B…òþBVâÞBF]BdBaÏúBY6B\†!Bp=Bk’ BU ÁB_‘ðBJ‘ýBX-¢Bbº—B–ÙBœÒEB’ˆ$Bš¡±Bt´€BN¬óB]¾¡Bz$ÎB±ÜÊBå=¥Bù3>BúîBòOB²ÈÙBípBÂ×Bî$|Bä”äBè CºBãïBÍÕÔBäÒnBâ¶ BÁÇÈBBkBWÏgBož•BO½BhOoBOªËB?S'Bi ÑB»¼B¤¶ÖBŸýfBƒ+åBeQ¿BtíBmžBŒi B{øäBˆ’ BdÎLBu+BX‚Bh5ƒBb]«BpòBT¡%B^ÜŒBg 8Bx‘­BT‚qB_’ÙBs€rBU+OBE"ŸBXŸõBNúB®MUBÄ£BÒÇÅBǺîBÔÂûB©Ç*BoÝöÿBH)ÍBWÁBLI‘BP8LBt½PB L?Bˆ6fBŒGBjB€ÆŽBXÜÊB^ìµBƒÚˆB»>NBÐê^BÓ<BØÑpBãÜ[BÜA?C !CSú˜CS[vC>—CE^³CWåB‚Ð0Baj5BCK§BLCÌB6ÔPBH¡þBPÀÕBXrBTJšBxœ§BVÿÞB]¥ÉBc zBHJ~Bb ÉBKàÂBHoBqPcB˜5”B•R£B’Ç3B•äBzàuBgdùBmtäBrmBÀœWBì@mC,ÍC›C§kBÓôB”'BÇøxBê½äBòF@Bݾ~C£pB߆¾BÚ:BÚoÝBâO¹BàÐBpÛBb¬RBSFüBSŽ#B@x“BR}B`wæBb´ùBŠúB¡í~B˜ž BŠJ|Bx*!BœÎÕBuJ3B†ÕÖBŠ¿‹Bˆæ Bnf©B] *B¹£²BÄýBÉCÌBºGŸB̵fBªÇØBcojBvÊ5B‰®ÊB¬ó!B¼ $Bª®ØB±×B˜O}Bt¸gBuÒ#B\£ B…·BCV BfŠ›By¡B„@hBtûB¯­Bx2ÉBi™KBdƒ`Bp(#BãÄCZ]CÂZCl~C]Bï³BQÑÏB…9íB`ôÍBmö™B¢˜§BªbâB³nCB³h~BÀŒèB•*BV»€BiàsBOì÷ÝB‚æ¼B‡ÝhB¦íÊB¼%üBÒh‡BÃEBÊýùB–¦}BSY(BT«žBE€ïBJ« BkùòB¼ÌUC!ÜCðôCƒÑC$T†C ÆzB™àtB't¥BZ$“B}zB`•œBb”/BkNËB¦ bB¾=B¬‰\B¯ÒB¥@vB`×ôBBâ¾BHQBWnXBN—ÙB^uaB5Bž·ÞBiœB—ç*Bœ¹KBrcJBdªÌB5B€¤ÚB¸ÒŒBÒá3BÝùBÛ¦cBð`%BÕQC)ˆ@CFC…CJåC@;ÆC<÷¸C ©ÞBuÙÓBtûBDHB\úB<ÒÓBRÿ¼B^uaBQzOB_†tB[àÎBeœ$BQÖžBeWàBL$îBGö¾BPÒ B^ÀaBjò}B‹RB˜d*B¡¨EB¥÷'B›ÝBdtôBy1˜B{ŠB¹cBBð2óCiC¥ºCú•Bä{B«[pBÃ,ŠBÛ—|Bò¾dBý[±CéeC¸„BГÇBÓLåBÑ’BÉ…BaSþB‚÷BYç BaB?„?Bhá¤Bj³üB:&6B’¡B¢ ÇB‹"ÍB€~ÐBoD4BãB~íèB…‹¹Bšˆ`Bs¥ØBMì™BiGçB€×B†? B€/¨Br5gBvÈðB[=©BZ¥B`Õ7BoÐJB_?ZBK Bl¸¶B{p BGDBƒ'BtŽ B1ÁB¬Ý¶BżB³±lB»P7BÃ*ÊB°V!B‚xÐBƒF”B‘8HB¤¨B¶ B¤Á¶B¦üÝBR5Bnì#B¸!BnÝ·Br @BJÏîBHâªB|èåBŠ>:B…{B€öFBmé|BY¥ÿBq{çBtèÓBÜOOCà¾C ä CˆC tB峡B{Î5BlÆ#BOÚB{ÈB°ZïBµ tB©åB¹ Bµ}ÖB‹šNBo“rB]{ºBd<‘B]ø¹B+¾B„±Bw¹BwnBvÀðBà+JC(F´C&²ÜC3aC#jzCè¦B|PBTøâBJgB|çïB}‘+BÅS¬BÖ0øBײ‹BÖß|BÔÀ³Bž(Ba‹&Bo0hBl7Bf8BBSâB°zC­CÚcCÑCªCøB•ÿÖBFÄ[BKŽPBu@BTþ¨BO{Bˆ£¨BµIéBÃÈ{B¼TPB®ryB£UJB}¿QBeiBPßÙB`%tBC¿HBcƒóB‡¯çBŽû°B˜ƒ–B‡6B˜§*B{¤ÜBr›gB9B€XBÊÅkBÆÖ6BÝ=JBçxÿBôB‹BÒ6³C>šC;CN½ŽCC˜ëC?v‚C²UBoŽ£BgÈBBI=Bl¾rBf•‡B`9Bn¨ÔBfjBB‚;FBb êBW«DB1”UBk ËBgbVBL>GB>eBh6ÕBmrAB™B˜ÂBBª›ÉBœÛBtµÝBS*cBvX"B½ÁBó›C5BøµCEiBÕ׌B¹Ž³BÖèŸBúìËBðOCƒsC ¼>C ïBåPBÙ KBÅ}ûB»UýBozrBtuqByppBe±¥BwáfBpö@BNÍBT«öB™ôEB£ÒBš¶Ba>B'B‚\KBŽj÷B„=õB‘¿óB~ìBBCB}nbBkuB€ä§BcªÝBc}ÃBi÷ÂBl#NBmìBJDiBVoÞBh3×B[¥ŽBn‰`B}”ÃB7üýBQV÷Be55B—ØBÂB0B˜–ãB¾ú¾BŸ~BžB›«XB—5…BdÇ*B}~B€þÿB~‹MBf[B`‚ÜB[õBg£ÛB€¤Bz uBV»üBú›B¿éBÛ4C 3?CŠ`CºECXBé¤B]ô B[<ÝBY&?BkXäB­RBÐJwB¹›¿BÂØ¥B°b²B†…åBh"ÇB„kB]bÜBdÇBl8íBh¨nBsvÅBql¨Bƒl¡BÑžÙC(xBC(~‚C6¼äC*¸uCcãB^J—BuCXBka‹B‰Ü8BiÊÐB°lPB¸œñB¼ÏuBÀoWBÎ"‹B”ÖOBW%BKÖBd} Bcl Bzõ B»ö&CeCÃßC‡CãOCÄòB”•hBh¶ÚBkOFBdÀoBAËkBm>wB‘íB¸FgB£±«B»4âBÇžGB§B^ù—B#v BTŸ™BEÖBibBlÍB“(üB·òÀBj•B„”ÈB˜ÕÞB†q9B`‘HBfŒ B‚BÂÁBÔ'BàóÖB×»DBå'ÌBÁ C$„{C3ôCKnyCJ³uC@¿ÞBêhüBqóFB@¼DBg8*BZ¬¢B[¬gB]{ÜBfQdBvàÎBT"™BU½,B7•÷BQr#Bk©Bx™0BdìªBe×GBc’ƒBƒÐ&B¤4êBš;B©„ B J„B˜IB{©ÍB_ÅpByˆœB¶Í{BåëóBÿñyC§ŠCÑÒBËÐPB¡Š9B±ºíBêBð÷ÓBö<ÝC•ÜBö\B̬BȈäBж'B¼35BŽ«òBq¯÷BUY,Bc2[BrôBU]ûBEi`B€\úB­IªB¤Z?B•E¿B‰ý°B‚/BˆXyB‹¯ÛBŸNKBuï)Bž×QBq BtJèBZBZíB}¡BR0†B…S›BcrB|R!BitBz ÁBX\ÌBK«ùB#ìB^Í3BTWEBw*ÕBewB€"·B¾‹¡BÄì2BÄ B¿É'B»I·B¤¤Bb.Bk‚ŽB—xB¬§B¼TB”8LB›ºãB¤ÓºB£u?BnâBZŠVBqyyBqÝyBqéBuªŒBmoÓBTžôB^Ž8BŒ÷’BS;0Bà÷BíBØ*÷C–CWCµPC­¡BÝ/BhðÝBfÈñBw€½BišB·vdBÌÙ`BµjÕB¯'yB¿s”BˆâaBlÝBqP!Bx¥ Bbï^BdWòBJ:bBq²4Bp´\Bƒû“BÔ$­C*›sC&EC2ØÒC25×C´B|çnBUxCBsæBt2–Bƒñ{B«áùBÐ)îB¼nB¿4BÌBªÎùBŠczBEùíBk zBaëÁB†•pBºFC×¥C ¤ŽC‹“C‘áC NöB‰“B]J.B[½B`úhBN¦BmN+B–™B°ToB›øèB³úB¼áhB®%MBnþÜB%òB`1rBP_uBRdÄB€XTB…3B”ßB›§-B€mBABr5ïBBôÙB]B…B¸¡mBÔKBÒñóBä¼¾BÜB¿À€C,hC5cMCTã8CA[B…›`BϾB¾ó B¿)yB»ÌæBÃHÂBË$ÆBøaBrT“B\*BeúBwþ’B€àÍBf}ÐBzdþB[tÒBpBï{C0§@C.äJC1JyC;è~C"B–Þ˜BK$ßB‰ ´B`'´B‡yBB§‘•BË%ABÃ_ÖBÑTlBºRB¯­B…Ç›BqXBsõBpoBWrBÏ›C9lC ŠC!C¢úBù¨êB‰!ÇBgFÆBt“’BNÎ^BL÷7Bf¹mB†ÑB¯JBœhÜB¢ujB¶5B²A'BŠŸBW]BP1-B?4&B_ȃB{:BÓB†B‘ÍB‹nBš",BoX'B3ÅB`–HBŒÃ•Bµé°BßqàB×:BÝ™HBáúoBÆ•xC0‰íCI÷ÃCM­CC÷xC<ž´C«oB‘W²BBAàBRóçBoóìBvKõBƒ\aBWHŽB`ÚŒBj¦BhŸBG7By(¦B‡AøB|CB‡…GB£mBˆ BbKÇB‚½ºB4ÔBÓÜBéõ7BîCžC C¬ƒBÌNÚB¢B²²žB÷ ×Bé¼CŸàCÂuBùhBá§½BØ«¿BËB¹‹úB“ÝÙB‚å&Bd+–BKƒBUsSB]DHB‚Û Bj« BŒ3B§'€BœÊ„Bj¦7BkmÊB€hBX/B‘?ÆB ¿AB³ÑBob Buy8BŒ£šBƒ}~BVöBoG.BN9uBY €BûBw YB}/×BrAùB;÷ËBfì|B\² BaÖuBKï6Bc1ËB„ÄB´,BÔÛùBÐA"BÉ9¨BÅ„$B™ÆB‰‹KBj½ÅB‚ /BŒ™üB£ZBš&B”Bœ“áB|nšBeÛÅBxgÖB„(tB…k‡B†p–B`ÛBxT›Bý¥Be‡(Bf%ÐBgY€Bvv¹BŽCòBÜ/ùC ACø¯CÜDCуBÙ(ùBr‰BVb>Bm­°By€šB½’BïdB¹éyBÁÓnB»BB…B^ B\óBlŸBp1ëB`NŸByZ$Bb$ÏBhêvB…Ž%Bæí|C8AFC<å~C2·ùC1,C1B®²BZ"ÑBŠ×BGsBxV‡BËÞ”BÂÐÌBºÉBÓÁRBÉ·#B¯EqBeŠBoBc…²BQ5?B|vKB½¦3C  CÖFCB@bèBTjiBp»XBiÉiB{IBBF“B`‘BIü(BlÓŽBa¦\BF8Bv¨KBªOSBÇBÂBÒ{gBÄÈ3BžþB…W`B„ÐÃBg½•Bƒ59B—ägB¬òB¡  B˜­ØB} ~Bˆ2 Bƒ1ÛBZKIB‰+©Bkš BróÄB„œÖBuWNB%òB\êoBz2’BfÒøB‡;ýC/|C°LC ÍC?CC Bæx²B‚z4BdÍ©B+Bˆ®.B¨_ BÇßBÊ\BµB½·B’f'BbaxBl%wB‚æBhžB[Ã>Bm]B`ÇÛBv 0Bš™¬Bû^5C00àCB#C1+™C'+C G'B}O¯BrF±BnþOB} jB~VB¾ƒeBÈZŸBÉö(BâûnBºü„B¡ÑBQ°gBnrâB[5æB^4BS®B°åÔCÌ:C"“C¸sCzªCc8B˜ B€¿kBtT§BCHêBL=7Bf®nB|àB¸B±™¢B®ŽÊB±÷cB ô–BˆuïBl´»B] B[ö4B>kBLêKB_$ B‰ßôB|BûˆB“gÙBƒD Bj¯mBX˜«BlB¾åBÔ/uBÖQ!CU9BÐIÝBØå´C7ÓpCKúRCHÇC:9ÜC1]BûÿCB†!ÇBh,(B_;´BZæBI­rBpœºB{/BSuIBY½ðBu¨Bz‹B^ÒåBW4çBh¿FBC‡BMÑBIþ7B{MCB§GUB©êUB©r$B©ëÆB” ÀBwUâB`] Bi‰2B¯ûBá¢=BþÆPCJèBûYáB¿›B¾CïBÇòKBõ¢kBó™¾BóßðBýfàC€BÚmˆBÛýˆBÍslB­ B‹~_B‚ÏMB[¿eB\kƒB0dcBK·B]BrËaB²\çB¡¼"B™ÛJBYÔ$Bs¢7Bm5¨B—’|Bp¤‹BŠ’€B‰;Bƒ8ñBZ*~B{$B…ðBZ{Bx›uB_dBtEUB,SõBcÖïBU{#Bl“€BFvwBQjBkyiBcbÕBY;•B;•Bn"BªB}B»C5BÂBÌaBÄmuBœ_(B]¶BoÄ¡BƒÎBóöB§ B¹ßBŒ0ÜBžêBxPBwôÇBˆwB{˜B˜_BRŽÃBd.JBZ¶ABg"BŒÛ B~B=B‰¶?Bx:øBv;Bü… CVDCÇC8þC }Bä¯!Bˆü«BjŒB„@,BgB²ƒäB¾“ÝBÆ?ÍBºOBÑsB–À7Bl›Bv_Bˆ†fB„vB[aiBNÈkBy° Bv@=B“÷¸C§ÄC, ›C; “C:‚C0‡·Có¨BmÈBaBk2pBnÜBjBµ(ÐB¾ÅÝBdzêBÈuªBÉÖB޵BwŸ3Bd~BNdlBz2ÐB-ÏBÀ¡ÓC%C+ãûC"šCˆ0C\tBzHîB¶ŒBo‘«BjçB>2By Bˆ]‰B­[B¹iÀB¬® B›O…BTôBnQzBqa Bƒ!'BYQ‡BONB`³èBfŽB9èB“ˆ.B¢zB‘eBˆÎB}ÜOBˆ¹\B B±€ÂBÅCáBàiaBü"õBà5BÎ?ßC+þ.CH#sCUUCI«„C5äŒBávœB{ÚBdÈ"BcJBWÖ¯BV;%BW<ÖBsPRBJœ'BFdYBq  Bc€@Bz§)BV+ÂBZà‘BeÕ^BU÷ÖB`Ÿ·Bn_åB¦ÃBµE.B°PnB«ÈVBœ BXäàBk\B‰QÄBµƒ­BüBîènCÓCàFB§f9B¬B¸À BÕ$ÆB÷{B÷4ñC•†B÷Ü»BÜåÝBäà*BÛr¶BµŒUB†šBv—½Bx…B€»6Bl@¡B} ”BX~óBm¾\B¬£ŒB´Y7B•MÇB^Q,B„7xB…ÂÈB4SB€ÿÀB”<ÍBX`BNnB„öãBƒ—·Bt€bBuÖëBmVÎBcÈBimBp$€B6C BQBRBaˆjBcÆ1B\ ÏBx{]Be4·BIÜJBHhB­åB§?SBÌ¢²B¼ø}BÏrÖB¹"ÔB“^–Bq±fB[8B‘Á B¯Ó©Bš7òB£5ÝB—÷B­øªBz‚B€(ÏBYôBi-B‡ÿBgu6Bf^^BLpâB~O2B‚æ¼BHæBŒÆœBj€B†"Bí|¸CNC ÝC›¿Cé¡Bé.ÌB‹¢ÈBmYÜB™BZÞ$BµüB´0øBÔD|BÅŸuBΚøBŒsoB‹ypB`ÁÕBƒ½(Bz—FBvשBl^B„¨@B†ÀNBƒ%;C~C&±ÏC9[qC;ˆ¦C,?Cì‚B‹ ÉBWêBsÈBk‚µBÏÇB”êBBº¢|BËžŒBÎåBÅ”áBêBpºHBGšmBWàÃB[ã®B#jB»¨C:C&’C0mCü?CÖ)BŽ)jB€‹^Bpû«BiÝBJg»B^ˆšB˜ÀB†ÓBF}ÐB[BµžZBô‚OBöÀÔC\BBü×õBÆ´ÜB¨xúBÁKÄBÚ‹6Bð÷•C Ž9C½øBÙBÙºBâSÿBÕD¼B´xBŠŽBwÅ+BW{ÍBj@B‚ƒ²Bwò[BaA·BU¢¹B¯%˜B¤ÍãB kIB‚1B}¿¼B“ôýB‘ФBuË´B–Ã*BŒNBeÛöBÂB^ÓBSü)Bp~üBOƒ~B4QsBfHaB|µôBZ}B}µ.BP‡„BcDõBVO B]@Bjr_B8FªBm+ëB‘œB°|œBÁ4hBÊE“BáznBØ~oB¼*Bˆ_éByQÂB©ºÔBªT­B“±Bœ9&BªJ”B²ñB޹B…—äBVRBUÓ>Bf/±B†y`B‚joBhlBŠWFB†d8BƒWtB”äµBЇYBæÔBò»¹CÞ?C¬CjØC¢'BèÃÏB‰.(B_A¨B‚™ŒBZZÚBµWkB¶á+BÆúPBÊyBÌÞöB‘T±B‡¤äBQƒfB†«_B‚Ç9BpW¯B€ƒBˆ5šB†»¸B‰çAB슢C-'ÃC/A½C13VC-å/C ·B›âœBZ¥ÛBw‡BbüwB^ÅB™ñBÄ´BÈ™B¿ÎBBʯÔB!ÖB_¼¼BwF­BGÇBk°BŠ2¼B»~åC8C=C*êC†vC®+B'BigºBZøŒB^aŸBoňBz5¤B ÑBÆIdB°K˜B¢Q=BÉÊ€B¾SäB€VBYHÑBq·œBT£eBfÀãBSŸÈB…®øB‡ØÐB„¼BŒ2ÀBŠf-B‘2BQôÜBdyïBuÒBe:÷Bx8~By ýBé†ECC*êÍC5…ðC&ÖUCìÄB©tßBƒÅÈBÖ—Bi(Bk÷÷BÁaÛB×.œB¹nIB¹+ðBÃ,‚B™6µB‚CBd0žBkŽ2Bk˜ÅB‡D}BÕ C•ÉC'—šCÌcCbCù;B˜Bzw~BBèsBkqYBquºBléNB©:7BÓ¥ÎB•MEBµb:BÂ÷ŸBÀ„´B€¦¿BT[¿BaøBZJBf •B„QBˆÙÇB‘-B‰…iB‹$ËB¡ÌLB†­‡Bb—øBeײBˆØÑBÈ®™B¼>yBåÞ7B×!¡BÄðéB¼ýÒC!é…CZ1-CE§¼CLûïC<=hBûïB_°´BO2˜B[ÄÛBp“ÄB‡]BeúPBF |Bf“2B~úLBfÌãBb±îBZ;B9ÿ°Bt+õBXRB„'aBm‚1BŒQBÏv B±hdB‹*B…GÉBn6B†UB[yÂBoÖ?BØx^Cð\C%NC"•œC!KÍCÝ¥BЋBhíûBVyôBtåB\ôšBrÓ B²BÃìIB¦ú°B±>BÇ yBªÎ~B€š2Bm5Bw€½B\LVBi;ÝB‰ªÜB‹(B‚B}ÆB«y*B¢\B‘¨ Bhµ@BmI]B€ý;BÖ|BÜBØ‹™BêØ¯BÓ$éBÆDHC'N€CX“CV §CAy CJBöýTBU™ëBYCjBPZ¦BaL$B„¹BabAB[¶UBz>©BpÍ\BaC|BX¤ÃBf"B\a}BcBf¶­BáùB€E”B…+lBš¤ B¢BŠïâB•çBç¾BŠ5ÓB—3BÚË•CríCaÉCÉäC ïBßcBk§#BaW¹Bx?+B€)B²ÔÖBÁöÞBÌüùB¾^2B°oB‰]{B†×SB›]¤B‡žÙBcxêBWjbB“0`Bá?BÉB•ÝyBëèVC+C;ï‚C,zŒC-Ï,CåB}´B‹K;BjÀ_B…gŠBæB¹BÉfµBÍtBÈ.5BÅIXBžzÁBg¡UBˆ‘¢B„`B…§Br@BÅ;C€ÕC#D$C&C Å®C´:B‹USBboˆBzxfBV/B}è5Bz ÈBŠí{BÇ”]BÀÊB±XBºBœviBo­BµcBwTŽBzµðBoÐ…Bˆ¹B‹þŽBœ¼BŒ;B’NkB•r¾B‡Y#Bhú†B{¢zB‚=íBÚxãBÞ˜§BèMDBéZBåJBÑXÖC%ÎaCM¼xCbÅÊCSo™CKV‡C¤ñBzf!B?0zBs›¬BX«‰Buv¬BVG B\ö’B‚=íBgšBS Bc›Baû/B‚x”BZó0BfKB€"Bd”‘Bs€ÀBÊ0B¦ØB‡÷OBdB…ú¨B‡•¶B‡7öB„XÞBÈEIBäWÎC 8 C ¦:C­(B§ “BžÖBÎ$*C¤xBä=]BðÎ/CaC åBñÑËBÛ#BÜÐãB«‹uB‘›BrêÀB\eaB±¦B`¤àBŠIBmÞrB‚ç¤BŽ3µB«¬¤B.RB\§}BvY¼B˜6B›éÿBßÓB…7ÑB„cÅB”O­B^ìïBb’…B|gOBvýÏB†£vBráB†½^By{ÞBf¹¢Bgà1BE —BgØ„BuBoÆËBXâ>Br?BU»QBƒw¼BÊ…:BÄÚöBÀ ?BÑ"‰BºuDB«®”BŠÆBFÕBж8B™»âB—lB´Ì;CWçÖD:ôÇB”òãBw ’BzVB‹|ÆB€­õB…e*BƒÌƒBym%B€Ñ B…+yB™ZIBjâBˆãeB‰ÂBÖíµC½%CùËC ÛdC·bBÚSkB€ÆyBxY/Bs­ BŽ<žB³gB°ÉOBÉGB¾‘ªB¯a6B™1BŒ·2B‡ï¥B† BuóºBX1zB‚Y[B“j”BƒêQBPtBâC0³C=EYC%UöC*aC ÑÿB‰ßBs lBÈ*Bv¯:B…ÙB±¢"B¾Ä BÌÙlB½©ïB× Bª‘|B^ÈùB†ìBfÄBv[EB]ŽVB<ÓB‡›ÇB€ÍBG3BQúzBoŒ×BÇÆBeËJBayB[íìBoª•BvcçBat4BgETBZEÓBc¬9Bj B¹ÅBݶ’Bß›\BÃ6ýBÔ´bB¡ëtBƒñoBpÿEBžñëB¦¶ÛB˜çJCQz!D¢8ßDŠB—]ŠB‹‡BiOBvîB”ïèBˆ¤Bˆ‡óBt-°BiÝPB—¤B‚!B}¬sB$œB„›%BÖþìC ACB–^»BcÛB}eLBo¿B|©ÍBÓaBÀÍB¿n¹B±K€BÖÔ!B£btBT‰¶BoƒvBg 3Be BbÈÑBÂÑCV‹CÉ\C$jC(ø3C>ßBQ7B]$—BAàÍB€yðBŒCBbÂBéBÃ;ÌBÉB·YB¶?IB§ínB)8Bl!BEGóBˆAÃBaÇ BVÝBpª§BUFB™FõBŠÑ Bm½žBnWvBS¬Boþ‹B•÷BÄaŒBÚ°BÚCðBâëQBÛ›4B¸fC)¬?CEغCZà^C_8%CNÄ#C@«B‡–›BI=iBaMBn®öBV¬BeeBE¶ˆB^íRB{&BjˆwB\ÚBLK$BS<BZµBV„qBe$ªB—ÿBoñB¦[ýBšÙØB¬¹PBµï{Bu»ÄBWâqBd¢ÛB†³4BÓP"BðÚ"C°9BôRBóuBÄnB£­ïBÄÌBâ—©BèkBò±ICW0C^>BÖÿBÌÎÁBÝP9B–ÀTB€’ðBZµ„BƒÈBg$3B‰™B„öBy÷jB^û¾B¡1QBŒ¥gB–öeBkgËBe+4B“m˜B£`²B„ª§BŽd BBkqcBgÞ BIâ"B}@ßBZë÷Ba¦BOíÊBe†\Ba©BwjóBA™ªBOa´BhH‹Bm²ÿBdý&B{ðBJ^ÞBˆ~ÅBv®äB³Ô_BÑ¿öBÅ}ÉB×_šBðµ¤B•{`B`‡Bt£Bš_BŸ6=B—#åCqM>DÃëôBâ¤6B—HêB‘æBuTB‚×FB‡ðB?”B…K£B‚\2B‘"fB~ŽƒB…ÆB‚å7B~‘eB€GBï›oC ¯\C £CNGCëäBí˜ B€l†BQ˜íBe¤Bya„B¬©BÁ]{Bª°B¸`BÊ ŽB›dZB€§¨BŒ±ÜBk¤Bk|BcèjBn„ÁBZ²ºBm`rBi2ABîõ‘C7'òC'z¼C@¤C.þÅC CB›3BfÞBƒfŠBmß^B’=’BªÒÓBÙˆB¿i÷B·/=B·B£‹ÙBmã7Bk¼ABysÉBc×Bc‘BÄ8»C ÐCá.C‰CsŒBó!ÕB”CÖB|…[Bc¨óBy<úBƒZ†Bf*LB…vmB©}õB³«>B´õ‡B½%­B³?B¾BB‘ÒBEô)Bo hBdAÖBkÂB‰ýŽBŽõB«&õB–B”ŸªBˆŠBm#ÞBeºÂBšL‹BÍáÍBü2BËØ+Bå!µBÚ¤BÆ;'C0ÍýCMÉCIç6C_/FCKôïBò¯BŽÊfBQÕ€BWÓ'B_O~Be`_B_þBU ”B~ì¿Bv ¶ByÑBR|ÏB[× BLÄdBTä1BZcáBf·¤B{æBˆ’”B¬ ºB¹ÕšB™—ÇBŤ¬B‹q¬BmhBd¡ýBˆXBá„¶Bö¶.BýŠC ÛBöM_Bß2öB•UàBçšáBÜ~¨Bÿ_Bú?òCÉ>Bÿ˜6Bó QBÈgâBÐ`B”‘¹B‹—,B€ŠUB]NBT”cBˆ3ÞBekéBqKSBb€ÍB‡DDB¤U’B(wBy{B[¥B‘B•¶œBZB [B—† B„ݶB‚ LB†bNB€÷BgÐBgçBYrXBtNÿBwh}Buè²BX:‚BŒBTÕ6BkˆÔBaz†BxÖB] ,B†CB‚ÃëB¹ ÉBÅ9B¸ÓB¶ÇOBÓB¢BmhïB}Ë(B•Y¤BêlB­Î®C…#Dèå8B‰†?B‚ÝìBåóB€æB‹ºB]ËByî†C?g2C3¤cCëBŽ‚4BzÖmB_"#B_Q@B™FíBÁø°BÈBÁ/ºBÏEøB¯¿ÌBŸ@@Bk\æBktðBp(ÈBn¿>ByBϰ8C#MòC*­qC&üC˜GBû°œB§­ïBévBoBùB}êãBwÝÚBeôIBŒŠ\B¢°B¾B¼ çB¾Ã‰B·­B™Ê¨BUªBi‚ÜBeŠ„Bd:ñBd˜B’¢îB„ÿB¥‡uB†+˜B“óB‚['Bh)«B? ÆB‹£–BÉÊ BïÝ7Bå_*BèBë¹BÕt¨C'{jCN¥YCHÀñCJÀzC;ü®Bú¯fB}²B_ý^B_Ë^BuýB¼BBCÅBkðB‹ÐMBlrÈBd÷gBY BmK!B[¡B\gBQUtBOtB_k7B‰)ðBœ?€B¢ìB‰+BžÔBž”Bt–Bl`ƒBƒ€çBÆw*BûÐÓBø(ICü-B÷¾…BɪeBœ‚TBð¦-BçhÌBö‰ÝBèÆQC%ߣBóÛÏBí±sBÌBVBëgdBœ(B…ÝBs*øBG@±B\(šB|-²BbºTBwL©BgýqBœúKB¶ŠöBù Bvp_B}Ó†B‹$B–I!B…)B…A7B‡–úBvÔ(Bk £B„ŽEBdéÎBT@âB€’VBYw‡BU˜Bw]BoM‚BU{˜B~û B]TÃB·B_|xBjó‹B|·„B€^ BvÔBÊj¥BöB¾ÄB×WBºµNB˜ŽŠBw‡ÅBuïB€CÎB£9ÈB´ËÙCž.rEgPBœ"gBj!B†z/B€Ä¦B‘éBOè‡B‰öByxâB€™ÝBeDÈB~³WB…2ÈBLG®Bk5îB„…´BÝß°C ßCý@CÌ»CœB÷múBh÷åBzPDBX]èBŒ_ÌB´‰B¹QB°ÓBÌ éB«ÝPBŒÐÇBxgÏBeƒGB‚G«Bx‘'BuªÙB,ŸB{ZœBr8(Bp©BÞ++C7ÑC@²C2ƒC#%CŸCB–HTBQ·Bz°mBVÐÊB¯dB²8›B±ëËBÄK%BÌ0KBΙB°è-BŽ8B_ÔzBigoBZ²Bv­€Bt'XB…›B°:B••÷BŽ0³B¢eB‚ÀÓB>YYB:ëvBzì BÏÁBÏ-2Bè¤iBú*ïBíÿBÅ…C'û,CXÊCMªC@êC4dCûMBƒBMXÂBqL”BY»çB„5kBCTXBcÔƒBzúuBt ŠBYtÀBo[wBoo©Bhü´Bl†xBP,ËBW-BfºÒB}3±B oØB›_6B”ÎrB…B¥eBt BYÆ{B{nÎB¿«Bîx·Bü C¸|BýàïB¬›8B™5^BÎÇFBôÊBäòBBׯ¢CC`ÁBë|KBУJßBí©`Bƒ‚rBPŠBrLB%DêBW¡0BW3“Bh×éBtGÉBQr€B_¥BYÿëB`WôBr ˜BOCÙBd Btû˜B[yÍB…‡EB¡YÙBšóB¡;BŽšWBŒbB±äBxd«B|xåBÓ¿½Bæþ+CÇ3Cm:Cþ]BÁÜçB¤â-BÇ}IBë[BîÑ Bð”øC¹ Bþ¬,BØ‚BávÉBÝœ»B¬.ëB‡…BrñBhÄ®B;]BU¡§Bd[ÖBR•ØBfåÕBšÃB­B¥\}Bk׊Bâ$BŠ{ BƒÏ¢B›Ñ'B’.OB–ÝB•XB‚F¹BtšÓBeªBp:$B‡bBaÞXBp'êBw¹BZ® Brô¦Bs1B…•B\ aB>UpBi B?ÒZB‚ðB’{ŒBÈ¥—BÔ\òBÍ#­BÌTBÅ›ÔB¨É{Bjz¹BYC B~t+B’D—C:fÜDüXD„± B´÷¾B‰ýÙBpmËBoãUBW>²BY·cBs^B‰vÁB…J|Bcä0B€{¸B‡pBGõ>Bm¯B€¼ŸBÛwøCÈQCèC]xC‰BÒ«’Bw±hBx&¶B†Š2BnÙòB±¹ðB´RBÅuÙBÚXóB¾B‹ùŠBdz0ByÿÊBEÁÈBTŽüBª/,BtM$B|ºÓBjo/Bx2@BS² B^1‰B‡ïhB“³æBžñKB¢_B7ÓBxq·BAiIBƒœ3BssBÆñ,BÓ ÌBÅKŠBßA2BÏ•0B—·C$® CAŒçCEfBzÃWBròbB`¯eBz’MBkÏxB8óBÜBC+èŸC9C×C3ÛôC%¿8CWyBx!NBdã[BZZ?BJ KB¸‘B¶À§B½¥BÑÔ]B¹tõB±EJB¥ ~B{¸ˆBk™žB\êúBc?*Bl§ÐBÑÔØC&XCCžÀCéCø‰B’-²BgõBcb½BOÕòBdoBh›FB}éB¨¼®BªôóBÃæýB²êqB«€ÚB_– B`¨ªBQ‰…BWïúBRä£BiíB„ B‰[B•éñBUÐB–Ñ1BtžDBX†ðBjÖmBoæ”BÖ)úBÕfÉBâÿBù‰?BÜÕ0Bʸ¨C1VÃCCFVCGùuCI9C7+‹C¢ Bd B+ûBmÆYBF®BZS„B]¼—BaùBâBuEBlŸB\ÒïB\”pBLq­BjÿÆBS^BcJ´BbüÒB|BƒÉBŠVøB˜ÈBŽLéB’tÚB`nBB¨áB‚5BÇŸßBøð×C ×C­`BëÛÏBʺB–âB¾<Bèt©BñzDBìMFCÜEBôAÎBסuBì¿7Bç{$B°ªBŸ¦Bv³ìBA(CBS?ûBp‹öB\LSBQÓB\¾¿B“IæB¥<ãB’›FBb¹:B…\B‚ ÑBqLBñBŽë"B•N•B]íBj6IBnSÍBh}áB†s§B€@.Buv«BwwþBSTœBh[VBU2BeŠB~ŠŒBaäBa2·Bf~yBVpüBAŸB‚àÈB¾²°BØuBϳB¿î BÀLB«(ÚBf;‹B@í‘Bž¤ˆB¤–C~b½DÁ×ÔBœÃÃB—Ù˜Bu¸ëBn'lBp»B}³9Bg«ÏBU«Bz²ôB^îB€Œ9BMB€EB{‹C<¤B•É;Bm·âBf®íBF)òBRégBcäB¼B¡ÈÛB²E B¾ÓtB»9WB¶˜BjäÏB_=*B[heBdBfê‹B[ƒB‰òxB|rB€²4B‹ZB’ÔBgº;BbàäBbcäBpwºB¼q\BÙ¿BíõJBÓ‡ìBã5ÚBºC.+tCELCHfCNk¯C3T]BúŠéBs‘õBD[sBK—^B!QBnbB-BeómBŠÅ BQ>{Bv<¦Bƒ…ÂBq›B^ò)BZA5BP0JBw-ÿBT{SB`ÑøB~[~B–gBh0B”dBˆ(ÇB\—HBH1-BUšÓBijLCgeCs6C|YBîXSBγbBžMBå´ËBñÞ?BãšBÜåþC ¤MB÷RfBêxûBâxéBÊYíB«àB5ZBlZÙBPÝ]BkÃâBT»¿BWIBwc×Bq®NBž¼¥B¦ÎlB$ÝBc{Bp(øBŠd‹BoO+B•tyB‰×B‰Ó©BlÕèBqÌDBo«GBrõµBSBJÇBn|Be~BYBBSÄÙBJÞB?OöBbC0B`R,BT–úBBØÃBSAfBbBcšB¼dBËO[BÄòyBÂt BÆaTBžpZBz]ÔBwÅhB ÆB­+C,)Dèö]B£>£BD:Bbý:Bd„’Bƒ2UB­B‡SŠB€ÜBBiÎjBoÿB…ßèBc&’BdŸ~BfcjBzrûB‡ž‹BäE¶Cþ"B÷áäCÙC„BÕ–BRBq¹UBW® ByvB°*RB¼êAB¶(ïB°ŠõB¿ÊËB‘'fB{®^Bƒ§¤BWBÞÏ£Bñ9BÒ*C.1ÑCCå’COÛÓC_^øC7 yC[øB‰ÉYB[hØBdæ¦BMþ=BàgB-B[vOBsŽB+ë/BdõBtŒhBb3NBq§B>*TBNGQBUCÆBaƒXBkMB!B•šÒB‡ŠB¥íBvËhB|^B`ª BtBãÔ@C>¥C¹{CìêC PBǺ B’áµBÖeÌBäJ Bì(uBåêÝC vûBçEBñ: BË,?BÏ3BªÅB“™\BX OB]vBr B?-ðB_I&BxôJBbE’B ¶±B—B”׃BZ¢wB`ñHB7RB’òB’ý†B~@{B‚•^Bƒs}Bƒ8{BlU+BG‰ßB^[Bj8Bu4GBmÙÃBK“>B€1±BT"BT¬áBlÚ‰BV¥BJ™ÆBYB^îÿBu‹—B}ÍWB¶JñBµ þB̺ŸBÊÏ>BÆÙNBŒWuB|$B†Ÿ BÚùB¦/OCÏ“ìE;PÞB¦>6B¡¾JB|£ BmèBmBxJ¢B‚¦7Br ÀBkVJBv3B‡*vBb‰jBf¢sB€ëèBSOBˆ(BäÆXC…C§šC À¨C ¦=Bä¡Bn]BmA£BTÿB{HB¬ÛyB×AB¢¸ÅBÇg"B _ÏBƒÖŠB‚€Bm\BBz—Bd¡óBˆNÄBZ‡kBD©[BVúÄBÉ&BÎU¥Bç¼BñZ Bêå¥BÆbC*5HCS³!CLJ€CUC/œîBðè•B‘ÓÉB[ÎWBq@¶BezKBb€ÃB{HúBk€™BLxcBJrB€¤FB^SˆBLBk8|B>7\BGÊPB[ØëBRIÏBnX{BšŒóB‹ËŽBˆÕbB’Ÿ%B€N7Bg¼.B_£B*MBÉ)!BèóBûuC¾·C _RBËÜõB„ÙB»šòBÞ`]BóuxBõCþBÿÌBê¹jBÉ!BîºiB®ä¡B’Ü4B;DŽBP-lBz ªB>RBU³ØBH¾ŒBHSÐB¥-”B’½ÛBšïÆBNo›B€”-B‚¹÷Bƒí{B‰¶sB2ØB‚¬ˆB‡ž“Bˆ¢™BcôüBOƒðBz®BDlÐBuÙ•BaÔBWúvBz/µBXÕ9ByžBp›BBTÞBR."BUÝOBj¿”BjÍBŠlÁB¨4ØB³$¡B¶ÒKB³ÑáBÑeúBŠñ÷Bd•ÙB‹[AB‚tiCZç5DÃW8E°.B®£qB˜§’B‰ ”BzCÕBWrdBNV«BqÖBh¬õBm;MB[°îBoX¥Beö»BjœB|0#B3ÍkBM65BÌü,CßöC ÁüCq™CO±BÇ¥ÔBwVËBNiæBm^áBn Bª’BÍ–ûB¤À3BÇÆB¤u3B„;8Bb<ãBT©åBn’Bn êBVëÇB€7VBáMBuÚBsVBç,C×ÁC>C)Ì’C+òC Š7B‚®–B5/Bp)MBe€vB±@B–oMB²CSBÆBH•˜Bp¥BaÓ¿Bw×Bc€£BTJBI€«BOï&BOªBbÒBF‚B„ÙßB³ãqBÊ>OB­È•BƹBØSRB¦BL18BgjnBzèÍC¬»þEu*D)ÂûB¤¶ÛB²g§B}ÆsB…c¥Bv»“BIfÌByïÃBsqDBsRB\4>B[¬«Bx 'Bc¸GBY «BCVàBTÚ…BÄÁ¸CÂJC‹ÔC ¬C ŒBÈ£óBg×B1»2B~4Bw,B§QB²¯JB¦F`B êCB¢MB“ñBhøBViŽBd~[BzBrÍÏBbÙ3BX}IB†BŽJ÷Bî§§C <£CõC-ìôC÷ÞCŽßB„³4B}ÖÍB\“pBˆm Bƒp›BšháBÀìôBÊÔ B¨CýB¸v!B¥u=B`õŒBUy,BhÐBh’•Bg©BÄïdCÃ0C$Ù)C×CTMC ½PBŽÃ¤B]Ñ´Baq–B{¦B/³BSé,B„–B¹Ò5Bª¨øB¬?7Bº-B°A¨BdÑBKÑBUçBy7&BdoîBp‹íBz¿tB‹vsB{ôBnÓŠB‡>¥Bmÿ BMÊÕBLB…¶ÒB´$^Bκ™Bã^=Bå°óBâ³BÔ §C-tHCH¿ C3¹TCAm»C*ø:CcÔBc¯ŸBPBN2­BUçBf#BrϺBE×CBY<¡Bl²BkȲBZ-úBa BU;¢Ba­4Bf nBXæBoæ‰Br¬'B‰í.B†;BŸd\B‹Ô3BšóÓB[ƒB\±>B*9BÅóBïa;Bñm¿BïÂXBù³ˆBÓÑõBª BËÌBÕìBó——Bÿ¨ CîÞBù®¹Bõ½BÚBÕ·‰B¬}åaBmëÏB<ì’BUX{BW#"B—ÌB *‰B“rBSï¹BQ°ýB…!EBÂÜBŒ±„B~?bBíBj,Bm¿·BxÕáBU4üBc³BJïB@âBZ[RB‰ÓBbÍ B„BVFpBS4BRï‰B\ÙbB0dåB]Þ]BD¥BQ)´Bœ´sBÍÈñB¾…ÃBʶ{BÇ2B`h²B<:8BZ¡ÚB”DC­àšE¦hC*V’B©ˆEB¤µ©B‡].B@HBj„0BYúŒBt.8BiB†L•Bi»:B\#nB]äBlÛ:BvLBMzŽBsÃ}BÍë'C67CºýC îCÜÐBØGBW^GB< BLï"B‹P·B©wB²é:BŸÑ¾B°-µB²Ž\B…eÑBH…BM7?B`g»BÄøB†CîBN;ÒBQ_«BjâBŠßACTEC-­ÛCÂeC-6%CÂCìBy VBv¦éB@rBw´$B`žB½¯BÇé-BÉåÔB¡QßB´Ý:BûB[oŸBd¼bBD:JB2k¦Bc«OB¹Ð CºŸC&:äC P¶CV¶C ¬˜B‰„#BlB[³äB}>hBPSeBxåèB{ÊJB®©@B³‡gBºb¯B»¿>B§í7BY©BMF¢BYrBniMB[e B`¼Bp9¹B4ÙB~…Bb´2BŒ²BnWB/ÛB4<BŠ ÁBѾzBÀ‚óBåÿBç!òBÖÜBÉ“"C#ªgC@BVC(ùÆCB™"C0ÕÉBò±BtÎÌBUé3BJ€B\Œ=BvsóBjºBZ|ZBQªªBdH BSSªBa]ãB>BHø¶BKmŽB3•¹B`$mBT'4B‚~ŒB’lçBޱB£æsB¡@‘B'BkbMBR:æBp^CBº‚åBü9îCÄ Bó œBÓòkBÀ`ÐB›a¯B×ÁjBà2òBïnuBå¦#COBæ:²BèÖBÖ~BÛבB¹Œ¾B„÷¸Bda B_¬BW–BN¾Bkf>Bb¶&BR¤ÓBo–ôBV›BYýlBS hB_ClB>jxBA BG“BcuB¤:°BÔy6B»õB¹YBºûcB”NïBmKBu¾ÓB]mCͬÍE>"B©ËâB®BØBnBn¹·Bm*­ByÊgBa°9BpÀñBsËÉBj­.BqäJBih.BsÏ¢BtègB`etBm,™BÞ&»CövC<…C ׊CæKBÞ^ûBPImBL©BDÑÛBuS"B©ÃµB¸LB±–Bžñ B£.#B€ÌB=¸ŽB8£™BEÌÑB|wB€"†BRÙB`kB>¹IBg>VBöƒAC.î3C3¯¾C5—C èŒC°žBköBT8'BV»Bh'Bl­­B·Ü[B¸àsBÁ«ãB­ œB¯ÉˆB©0˜BiBQ(B83BUäÿBtòúB°éƒCÔ C(¥CêàCñC(óBxq5BZqkBCÐ*Be—BBQÞôæBD¡ÈBI¤xBRðEBL•B@]yBŠÂ:BšiéB„®vBŠ¢B¤òBÈ(B[\ÿBLÌ)BzZ¡Bº­CáŠBݤíBì/þBÔÉ$BÄÚOB¡Q²BÖTVBßÊìBêÅBÚ‹-C BGwBx—mB¯èÒBÃTãB¿'BÀWzBºÔçB—=dBnåBvY”BlšdC­*WE^B¡ÄBžÒºBˆG–BeÝfBbð]BY„ÔBr;½BMrtB`"Bt× BqA¼Ba¯5B]™Bn“BfŒfBPŸéByíìBïhC,C ¤C¢˜C ÇkBÛ‚¿Bg¾BG:Bd”B„‹ÓB ý‰B¯eB´¡hBšŒûBŠz‘BlÚÒBkIÛBZeÔBTBf\BOà‘B Bj¶¾BLœþB^¥SBÔ5…C¾«C*ÎkC-ÁwC#âOC 0xBBUo¤Bp¹3B[¦BTêòB•φBÊ©LBÅœþBÌgîB°ÜB‰ÂBa‚úB@¬EB.H—Bu Bcm]B±ƒÐC9øC"ä9C x‘C\CåÚB†õœBJKºBCI€Bk‰QBC=öBYAB‹À B»@B¬9B¯ZB¼-"B¢æB[/ÀBKœBa¡¿B2¿ÚBCðÎBf|Bƒ½B‘ BB’’®B‹÷VB~Ô»BŠCHB<ˆ§B&å?BS¿éBºÜBÄÃBؾBÚí:BÀ­ˆBÆßC2C7EGCHNÎC@-ÍC8A3Bàâ:BmSøBhˆBOsBM§VBCÀºBS÷®B.ä[BM/B?AÅB'q¢B@{;Bb!¢BUšèBJKºBWiBZÀB9¨By»B˜éB„ïÒB~ÇDB“wBŒþQB?wžBT:Ba–5BËEBþ[eBð+2Bü@ðCB¸(ÅB¨¥BÉŽ BèYGBøZaBÚpC -‘C;BÒÎcBÄ9BÄDÃBœtBv·ÏBHláBF̉B:!FB,|ùBV$hBsÓmB_f˜B›uZB§æ`B‡h“Bq¨TB_-BˆcB›¢îB•éPBkXBwÒ°B¤-BX¡ÓBiËBJFýB{DtB7OûBlBceyBaõBe©Bi¼îBI*ûBUߥBiñ´BeÜÑBPhµB] BP[GBpB§`†BÓ(ÈB¿°B½t,B¾*bB‰‚œBgîzBLvÄB¿LÄCóOjDäùŠB’8åBŸ§ÓBñB`B\"KBc_,B_üÔBlzçB=c)B{wmBdÖ,Bq‚Beä]Bu”³Be‰BSã¹BvüPBñ3ACVGC CCYÒCJ¿Bì£wBvîÚBM—9BQ¾¯BŒMB§¶RBº{B«%*BªZÃB—ÓB]R$B]¤ÔBiÀÒBcûçBYá_BR ¥B|íBMbWBQ¯Bs –BÈ[C SPC'ÀþC'Œ–C&\€CÊMB€‘¬Bk—Bi®ŽBqï BHNB›y(BÁLNBÁé„B°…šB¸ëBƒ‚ŽBj±5B`8rBgäÜBW|ßB|ZYBÀù"C 1C%Y^CÁKC¤áBþCBa¾ÓBIÏëBhÀB…f5B<æ)BW8›B‡s5B±6‡B´$†Bº)ÞB¡¶B•oB]2hBFyBBNÅBeXðBOÞáB8Ï B€>B“½BŒ,ÑB™¨AB€ŠñBŠ÷°B:°ÇB,Ó¿Bf:æBÂ×BΪiBÖª÷B¾¥uBÉoyBÕ8ÆC>OC;ÅCT©˜C<¢äC;XBØË¬BwXŸBRôBPš`BFOB5À\B9o BXñóBiŸ+BHñÏBh×,BWýBA‰¨BXAýB?'BQqÃBWoiBLfkBrrÇBŠÔ—BŽÊ‡BŒ`B—öB‹W[BGÅÎBA¹¼BcúñBרTBî˜èBöåçBòQËCFÍBͰäB³^rB¯TPBèUBñ‡ÞBèYàC}WBæÆ‚BÄ¡0Bö’BÁºâBœ"B^PòBbŒ™Bd&6B8KQBP?þBTZóBEà;BDKmB”תBŽì'BJªB„1B{M«BŠr B•SëBŽÓ¯Bq‰>Bƒ»šB€´BS ÎBIè’B7aÓBrÇÊBZ›Bp˜BFNBOžÕBT“FB‡OêBJÿÈBvߌBXL B`ƒ?B<¨ÈB]ÏtB[å(B‚Ý{BºcÐBǰŽBÆêLB°ÝãBÉFB‰þóBcbªBEʹC5+¿D”ùDN©JBžÕB‹¦‚B˜Ÿ§B_BæBs9vB`ŸïBUÝB‡´jBVBzÄ:Bd@ÇBycXBi©dBzÜCBeÈ BYl¬Bd/yBÝç«CL,CŽÝC>¡Cj´Bß„¥BiRÛB_¥ðBR2­Bƒ€ðB­þPB¿B~B¬zUBªB²î»Bwj‰Bu(§Bu“BHí›Bl )Bt§ÏB}0B;î±BRŠ-B…KBÑFC-ZC/5C),›C*Í«C7KB{YDBdHyBFðôBFÍBaà!B™÷âB¿ÃÒB¾Ø¹B¢L’B¹×õBÂMBl‘ŸBG¥¹BnÁ¼BW‡BBŸ0B:¥ÙBkW3Bc^ÑB}[¯BeÏÑBS*ÁB[ŠûBRªÞB0çŸB)Ý´BE«ôB€²«BhùnBG!þB…º¦Bœ8B«zB‡êBB‰ú%B•ÑcBt7OBF-ÃB‚~BÈúóBéèABû§ƒBý—/C®KBÒù™B¤>¥B¥j*Bó•§BüºCÄ­C ïGBêÜBɵøBÕ¾@B»zµB£ÐBj¸‹Be—Bf B5DíBwqDBZEBCjBIžˆB’E¿BŸêHB‹ÇêBùäBv B…óBrãB~¡OB‹ºB~8ºBz¤jB[X±Ba%BM?B_ÒRBNBY4B^ {BnBdh»B|o BA’KBnIñB_™¶BMèîBDLÍBK´¿BKƒÑBk$ðB»€˜B´`B¹ùèB¸ÂB½™zB‹‘VBYw7BB'ìC²’E*WLCCB‡kBˆ¹B‡«CB„pB[WBWËBAÑbBlÖBA¡NBf!B]óJB~ ŠBƒšfB}Ê:B€œ‰B€^ B‡Ý¾BÕKTCZüC ,C »[C¾BÝu:BÛÄB[nBaß"B^óB®ŸB»;¶B©1tB©SB°j}Bc\BOYÌBOÔßBmœåB†ÓáBt|Bb|ÓB5nBPüB‚PBïÙC&9ŒCx£C*L“C'×?CÿBƒ`:Bj` B8øBK:þBc(ðB›õ{Bºª…Bµú B­OKBÃn¾B‰²ùB@œ»BE–ÄBLê¹Bk? Bg…HBÅ-`Ch¾CfCøC[CÅšBrB@ÏBM™¹B.KRBAM§BLyBB‡§kB ¡¢B¡öB­=B®J½B•šB\³B`À˜BJ×BH5ëBX\†BGbaBn½Bq=¼B¢öCBŸÌBŒê‡Bkû–BRb¸BW0†BoËŒB«Î®BÈÄšBàÂjBñ’@BìmnBÉC ÈÃC[M~CKqiCDôÖC?’·BÜR\Bc5pBk– BU]8BLûBz°÷Bs¼2B]Ã6BFèDBL™ôBf£RBD¦bB:Û¨BZj|BK àBd×µBkxÑBA"cB„ÈÎB–BšròB˜YBŽ‘›B™¢ÅBw^÷BXFhBƒ›ØBÊ BõÃSC{›BãhLBñú”BÛSB«j¯BËdCWBëìCÿ†C±NBæ¦BÖÕBÒÉüBΠB­LiBp|xBY-B`BDëBh°QB[/™BL5ôB@2B”žuB VÇBˆ!rBdÄBXŽBi=©B‹^ìB†°…B|ÇBt çB€¡ýB_QåBŒˆBs™¯B\¯`BN%†BP˜BríïBfë½BhìBhÈB:YBIÇ·BV¤®BPÝBG‡BDbB?žŒBa4…B¸.B¿)›BÎ)BÃ|fB¾äpB~5BSÓ_B;°‹CÕL$EM¦B’œäB—äÏBŠ'ƒB• †B‚ÇB[ |Bi% BY%ÞB\B\•¬BZ8ÞBr"Bp¤GBWöB^4Bf'«Brÿ)Bš…gBÕ-;C e¦C ¥˜C Ì C-BÜÆkBØB_gÊBi]ÈB…\B­¡8B½B,B¬€GBÇ¥ÇB›l,BzWìBAÄOB?'BwãBƒÔÄBò‰BE »B:˜¼BN3ôB‹x‡BøâC&¸Cœ C)Õ¯C#]oC’Be’¡Bf%¾B_¶¢BuÑFB‹ÑyB¢˜BÐÑÙB¼—BœÚ…B®"B–•BKòBHˆ Bt9•BO LBIÊ&BFìBNôB+›?BCÅB8½B[UBƒuB‰ ÈB•‹ÙB”ÿwB‘)BgüæB7ë)B‚:¬B¿-„BæGBþÀyBíÀBÓ¤rBÁfCB³IÆBØBæÜ Bâ<~BùºC ¶BÝNzBâ×MBÐ+üBÇ#}B±†BŠ¢Bm0 BiìBG£0B@ÏBLß‘BCá§BCvìB˜oBˆ©B‹ÀB-ÞBJ•˜B\é}BŒvãBq§B’EœB”·2B}åñBQ<¯BfÛøBX5UBGçB;H÷BeuB[_#Blt|B]4SBG~ùBX×|BR•#BSßBRµÃBK†lBK¾BM‡ÀB\¸ŽB¹òÀB¼«ÑBµeÍB¼ÐÇBʵBzö¶B3ø¸BKw C’ÇE%lB‹¾NB˜+B™a¥BŽþ„BIGBK)=BS’Bo¥šBKsGBi LBVf(BEyzB^ŠÄB$­XBTŽ BoôsBU“•Bw{BÔ›C{C±åCÃÏC"Bä1Be±ˆBaf~BW¯öB€*_B¯iˆB´×êB§ÿñBÂù7B¶Ñ®BªBQGBOÚ3BL_ÑBn¸BbZ¹BP¬ÆBQéB_6áB„gwBð&‘ChCèC$:$CLBóT‚Biì8BDâƒBV ÐBbSÿBs.BœªBÐ7B²oBµQB¬,±B À.Bx«5B>øBI÷yBI%ÛB=ygBÈ­ÉC‹C¬«C ^yC [–Bóò®BVB6ë†B@´SB;»@B4ËKBAB€(sB¬¬“B¦^(B²yB¬œ:B•ñ×Bl ‡B`'DBd1B0†BCðB4#B;¿B’×B™–B~ÞB[ÛBOš‡Bn¾êBpéBujÌB±“B‹Q_B~ÇšBk¥jBU‡zBNX$BMÃkBLéžBpL$BO÷™Br†Bo‘ B9¾ËB]ÇOBY4¼BWþÒB@S§Bk×OBi4ÊBRi/BiûgB¸©¼B­¯àB­öÇB¸ÒÀB¹lB’·B5O3BxŒCTÅD ~Bî}B›]lB§ªtB“wPBJÀ›BaöæBjá–Bi QBMú‘Bz©BbBÜB;¨2BO_B@yØBC°BQ”®B^ý]Boƒ)BØ„«CKC ²BçÜ‹C—*BÉ<©BgyBkGByF1B|“bBžÊXB¡¦B»:B¶þ{B¥ëWBo¤ÐBK´×BqÇBO¸¸Bx*ŠB`?B[0JBrú©B^Q@BxˆÄBãûÂC0ŠWC&EC.!ÁCÖœBþA9Bu\EBT¯ÞBU¨èBXõ#BW#ÁB£î°BÅŽÖBÇ}B»n‰B¶½BŽ„øBSB7eÏB_GgBJ‰ÌBVNJBÐPC/ C«wCÖUC!¦TBõU“Br¢2BL¯BOc%B÷·BE-°BJ9BȇB¤ý×B¨RB­{ßB¢-+B™3B½XBfJ—BUZB6 B3qQBHÁBaB‚DpB…¤ÜB‚c°BÚBr;PB::ÏBBX°Bu¥YBÇî B½3æBá£ÃBìBÉçÑBÃòÑC*ŒsC]¯CTÌIC=­OC7Ç8BÙDúB€H¿Be*!BQZýB=€BT}ÞBAýXBW@BQxËBYÿ{Bi™´BFÓÍBcÿBWüBOyBBG¹B4d•B]¤,Bx%»B™TÀB’jBÆB„œB¾nBjeŒBlkÑBŽcËB´t÷Búû¹BúÊ4Cî2Bû(oB¦ÃB¤WBÁSªBäüBÛ„CšCušBîøABüíÍBÔàñBËdB­ŠLBuãÙB`?Bl`GBH¸jB$½ÜBeÄðB!„ÝB&?B“BžvÎBñB3&ÓBYèäB„£sBy”B€{`B‡²ßBƒóBúBm²BS=BZ×BM³×ByþBkBeòÄBU¼BUlbB<áBV#¦BPµBd½ÐBH˜BiºäBjBMòBw¹ŸBÊ‚BÅB¶µBÍ’1BÁ}BLÃBE°KCúÚD¨(D$æçBucÍB¦€KB‘|€B¤ºîBgÿìBr"&BPñBT±¡BaäBqD BU_«BP(Be Bj‘BMrÓBeäB©ômB»ÄƒB¿ËGB­kìBµR B‰äÂBQKpBHZB]dŒBGºhBb³2BÎZ¬CqcCÿÏC7¤C0çBü B‡=êBXe´B0°YB1Z‰B\9ƒB[Ü>B…pÛB¥$³B¢dÛBž—ÈB§*÷B‡jŸBfÿ2BD>BS†—BBRÂB0Ú§B%Ô‹BgÑÅB†æiBƒÄBu5¥B•0Ba,ÐB>@tBOIBquBÇABÀËBÓV&BʨBÒ—IBÃC2ÈÑCX*¿CJ‹¼CCé©C5DBÔÜ Bl4ØB\JÑBISBM,¢BI²AB7RkBrÁÃBEÊAB@ÿUB[äåB4¶&B@MtB:ð`BP,çBSÃ+B8CÃBBî‡BSÓ„BŠV8BˆL•B“ÇÿBwáLBlÂ1Bi¨BJJBq^õBºú—Bö1¯CŽ{C¢C¬B¸®!B¨E-BÏ2‰BéR€BÖlˆBì}CNEBúïBÛYBølÖBÑlB§ûŸBXÝåBjEBT¡BE òB%cBb¹îB2ØB&#dB¡xkB«ÐBŒJÕBgD¹BgTB8B{)¯ByíB†ÇèBnÛ¯B‘€ Bi=jBcBHVBgœÿBxn7B€¥´BPÁBE€±B<ŸBJ²‹BI—B]ÒÐBR~GBEBM Be–ßBGQB‚¡ÁB¼}ØB¯MãBº WBÕÔÀBÈq[B[­gBQ—®C‚?¬DôuVCwóUBŒþ)B¦ÈB‘©ZB¡¯DBxßlBTˆB3"–BB«BggQBnÚB]ÓBdœæBI &Bn)BrSwB^+ÝBW ÞBr²Bî7 C àÑCÅCâèBþ÷~B™4B[g6BmŽQBXY|BwŒB»,ºB¿+B± mB¥Ó[B›´ûBgÙ¿BZÀBXBhÔ´BBlB[0gBT¤sBo‘³Bh‚BjGÛBëCÒ€C6á¯C1lTC2©eC C›B@ýBACâBW}JBOþBaô!B«÷óB¼¿BÃb¦B©ÉÇB¸(#B”JèBY‘BCDBQÃéBNµ8BuB¿Ý°C–ãCá—C¶îCÅ®CÝ~B_?ÓB8ªíB .BJ3aBZÔB8±¨BtÎB¯ç¤B´ômBŸÿB©yB’…BV•BwŠBG\uB3øB1õ B8àÆB5øŒBH\9BzŒDB‡iÍB ÿBƒ‹æBcÄB^ŽçB3T–Bb[úB´ïžBÝ™°BðBô,…CÛûB¾SðB§QBÃÑBËÑKBÎE-BðJCÕ{Bð)™BȾÂBØ=“BË‚sB”7Bq°÷BF#õB*Š—B7B9 BR?óBIˆBø}B¥XVB—!õB„SºBy¢ÉB_.·B„µ˜Bw‰Bb`3Bˆ@ËB{EB„õfBV²oBaÐBZBQBT(ÝBE¶ B1ð½BW”àB9¿ZBgÂBMa&B9ÏB“„B9hÿBOÌBQs'B1¦ÜBe½ÓB®:ÍB°¶ñB³ÑæBЋ‡BÅî:BbfÕBc£CˆÐ—DùÎBª*B°zäB™#èB‘7Bˆ¡B„»gBR“áBM• B_¢-BRw BoqIB†”BODÄBIpvBSìBtuåBY,VBG íBqfBó†C&CЃCVuCCcBÄÒ“Bm™+BLBVþ¥B|TPB¸¹wB£hEB¯óQB¹ËB{Bƒâ”B}‚=BYÒ®BfÊÝB[VBchBZ¹sB{=xBNWDBzÿîBÿý+C-ýPC6líC-ãCíþBúŽB†–âBVÐ~BPëBb"B‡–,B ”BÄØBÅ(&BÀD:B¹mFB˜­(B]o®BC³É‹BK€Byt½BÇ^~CkêC1Cl•C.“Co¾BSG¯B)rB<‘GB.\¿B(††BE2B…'“BŸç'B°yïB¥°gB«ðàB¨ÂBdrB1ëSBI¢vB#A|B3t—BY¨`BNöBrhåBÅB–*_BH×BWº%B9´BbÆB‹!ÜBÙ—B¨9ëBÎ)nBÖˆ²BßvDB¹ŠC#WCAÚ(CKùC6²àC$‰!Bã œB9 B)ñüBD¨mB8ÑBNó B\ ßB*Þ…BJÃâBG`”BGYÙB>^ÑB2¹B'hB1.ÝB>*äBO;&B2fB\>ßB€h2B‚‘B‡²‰B‰—¡Bk zB[mBBG«”Bu;B´rFBô4ÔCЮBùÑØC*—BÅÑaB£ÌÀB´4¼BÎkKBåâùC¤C÷ïB÷³BÝöBÞ ÄBÀ[ÉBšÝ¼B‡—œBWÚÖB0UŽBKmBJvBBîBi(¢B#UB¤ý(BŽ_œBuŠúB^öBL1çBá£B}áÖB…H_B‡wFBj`©BiT÷B/úáBZPKBJ\¶B?r¯BLO¥BDùîB7à„BI&ÌBNšÚBtüBEG¥B'ÌQB-rCBI0eBkÖÜBKœ9BC™ÌBrå”B°HBÆHÅB¼/)BѬÄFBH’×BjFµBk4BÈ[CœÔC,KC†7CA›Cq¯B=çB?>cB=oãB4”–BAYB6•B‡ÊWB¥e¥B­êäB§É«B² •Bˆ‰BQ`B.ÅBE¬ŠB2" BTïBBK^:Be¦B^ ñB‰i¹B§šŒB‰+BgסB6¦dBf<Bˆ£+B¹¿»B°¹¤BÈ^BÖUûBÆÞÛBÅoC)‘xCAUYC<ëÈCAŽC4?[Bçh¤BjÉzB2ÛB>_OBGºB5ÇQBXüÁBPXBBOz%B.“B2¢‚B5 ÇBO°ôB6ƒÇBIœBZ‚-BbI„B5PBs ÐB€ôÓBŒìGB‡CB—’·By¥PB`¼gB<FBtB·KÙCâfBú]Bü¬ÜBõƒ±B»:B—ë-BÒĆBÞ<’C¸PB÷ØSC JBþ9BÌbàBïËEB¼ ¿B˜)2B„o5BYÁBN®MB:udBA*±BDä‰BB|1B-óBœ|eB›;qB„¼Bm¯ŽBh%nBvx˜Bu¦wBŠÌB‰ ’Bd)B\ÐæBN zBCÑB\^¸BJBuÝBGómB^û{BrìêBu"BXL·BG¹ÜB?0%ByÝãB:+dB[?ÕBb'6B<}BziúB¹Ö%BÉMyBÕiBÃýóB¯Ï$Bž¤pB…ÎÃC‰k^DܵB©ÇdB XB•2¨BtsBžIB_ˆðBD¦BPwABW·ûBBºëBi=B{ú¦B{ÎBDYWB'®æBCÐÎBccyBd ÒBo¡BÖ…C äåC nëB4“ÚBLrjBJ—jBŽôB—nJBŸA¦B²ÚwB«#óBŸdDBQ²¤BNè8B)ŃB;âBNIBDe×BkÙÐB‚â5B‡ÎÈB˜|Bƒ\RB\"BUÜB6BžB…@uBÁÙàB½ýkBËÓ·BÞlÃB¹S¬B¸r1C7ó}CJÓCK:’CAÚC>oWBó¹'BY‰]B;I'BRèBQÞßB)«BSÏBQ|BUÀ#BDX`B)YÑB-¤ÛBNÆ‘BD4ÍB_ßzBH"‘BUò"B7\YBpË2B†i’BŽ]$B‹,QBŽò©BXBZ 6B\ÜSBz$uBÿBÛC¡BçÊÕCóþBø>]B¸W¿B¢ÛÃBÙ§œBãUBö¼ÉBêíC ½ABõuBÏ#BÏxhBµ6B•èÞBgáyBW&ÊBCËþB0ŸZBCNBH3àB4Z(B=¾öBŒ¨GB°rB˜aBwPBxB~3B|=ÏB| B†òúBq­BG‚ÅBlz3BfÕ6Be¨B4”eB`jBPÉ€ByƒBcôSBn¢ÝBF}ÊB=;ÛBMOBg8 B5àaB%ú;BQ˜ÁBHÔ‚Biˆ B²5ÞB¹ äBÌÍCBäB¨ÁnB•oÅBÿó}D5Dšû°BŸöõB¤©\BÉšB“¦B–^·BbëeBHr~BH×BK›%BZ/ÓBZȶBeÜHBƒæ\B{ bBT}-BPgBKúVBVú­B|œBàdªC yºCàkBý6ˆC ùBî:{B^vB4£ZB??°BmäB™oÏB°±(B«³FB© $B®ÆB|À×BgZBb-ùBf B?TØB[ÒBqSÚBp´Ï1BL:ÂB>Ð'BLT¸Bb RB>ª§B83ÙBX3,BK—LB~T°B… B}ÍB~ÉþBbû¾BU@^BL¯Bd·ùB²BêB#Bõ7çCâ€BêŠAB¨ˆ8B¥v¥BδËBõM‰C-ïBù=´BÿðšBÚ±ˆB¿I°BËÑ^B¸£ÄBŸ;uB¶¿BKRB8Á1B'*RB©qB5Þ{B-B+È€B$öB/iIBKbçBs°GB¦DxB¨_9B³¸ÉBÎæB´ ÍBŠF˜C7ÚˆD–ZDŒB—£¾Bš¢‘B‚2B—-ôB‹|±Bv°ûBN`ÑBFzBSì Bi?¥BIÞBaÍáBuRBvTBfßôBZ?EBM ŒB2ƒ.BzæBØyÆCÍC›CèˆC ÷;BÙ%hB`õ‰B'áBBõ¿BUgÙBŸZBBÂ6FB´;oB£ÞB~KB„h­BfÆôBrÔBo4¤BHNùBqÅ^B{ zBàæBJK BX.lBß×ÔC%_ CLC"Ð}C À›BôÖBYfìB\§B]ÖB2KiBrB±JBÆçBÉ'1B ßB©žB×Bk9jBVÃíBg¯BXtBaJ&BÁéÔCÌCå]C¯C»³BÛ<üBm$ÂBZB5rBZFöB6à|BT¥žB—44BÃ4™B³;ªB©ø B—Ì B"WBSF¨BD£B<¯BOedBO9)BZ»B‘@+B„=hB‡KžBŠ)ÀB~ðB\–NB>È„BFBxrûB¯ž«BÔ¬9BÆ*ÄBÂWìBɘBº)³C4dCJ›CR¤íC@“ðC7<\BÒT´Bu~@BYª;B5ž_B(¦B3 ¤BLà3BMWnBL”=BbÅôB;/]B;7B5X-BG¼ÑBXžB&£ÄB´ÅB;ßTBfâÖBŒv±BÕ¦BŽ%uB‘ÿÿBm&®BV±BVD B€ B¼cäBñ³îBý/YCVBìÀ¡B­ý\BrfBÄV€BêCVXCÍŒC@DBÕœ›BÄ lBÞ BÇ—¬B™u›BxT6B6ñËB>#"BGCªBPs•B>$BZ—»B`ä:BuB”“BhüBUçêBP,ÛBpìÝB€šëBqîB‡I¯Br´ŸB_JyB`³BLÓBH÷ÃBf9†BD$æBX™ÉBV­B5JsB>a5BW$‹BQ¿×B3T£B²¾BñžBM3B'¡B@ TB€d;B¨'ëB¯L³BÇ•B¿'+B°ã¼B`J…CYÞ{DÃoBÖO…B¢#ÉB–ißB“eB“îKBŠêBlZBG» B\!#BMÝ:B?Ý•BE0BGbB_uBPu¦BT¯BO?B\"B:ÛÚB‡‚BÓç-CõtC MŽCáC‹óBÅHB]Š­B=«BF¨BX.B¢þB°¿®B®¯QBº6EB’óVB‡gB?H‹BT$êB9BS‚iBMþàBb´ÉB} BDQöB^cüBÖcC ‡8BóDBÞpÄB×£lBÒ+mB˜³íBp BG BH“BL›BE+DB=Þ BR®àB/ß\BˆôëBW…Bvh(Be2/BQ©UBYMºBƒ?žBry§BeË´B{!BJ³BO_B]³5BK4BSÒBI=]BMÊ.BYF B5&‚B7Z°BküÇBT2èBAIUB8<+B!‰‚B`êsB,qŸBa{Bo«ôB¦aÜB·KŒBÄ”ØBÅ›tB¾P'Bv([CxÝ~Dá¬ÐB~¢ŠB”]=Bˆ2ÒBœƒJB…@úBŒVoB{©öBZ¯®BKð°BDeìB3¦oBV_BO’BM,BW2iBWdiBip—BWŠßB+–úB|²cB̰nCgøC”ŒC *#C ’=BÛ;BJˆB?¦‹BXnÁBk 4B£kB£t°B æØBÈ‘%B˜)ZBs+îB<'ZBP®%B-óÉBc*ÓBF’§BR<8BpÝŒB?;ÏB\1ABä6ˆCеC) C6xlC0˜WBó˜B}FvBCÌB+"¢B_w¶BdvŽBœK…B®6 B´IÐBÃ(ˆB²d·BpnBV0¸B*L6BO{jBDƒ»BwiBÖôÊCÏàCÍIC€MCe BìaßBi€ðB5nBBAØBT›éB`ÙBS(ÂBr†ŒBºo]BñB§Ú+B&ÀBŸ‰ÏBXÏßB*fB_XòBE„vB_Ç…BOáVB{¸cB~†§Bx§ÆBŽP4B…6fBbç…BX'šBh¹æB‡îB©B¾Bž{B±»|BÍxéBá;BÂ+¦C)Þ¶C4E4C?°ECLwæC/ÄBå‚BBoI´B9·QBnþ´BKúMBea,B*¬]BFXB>ˆ÷BcÊBW~_BLWB2>BU.BQ‘B^€˜B8zBU?`BnpeB—M£B‡kÉB…ÉB”[ËB†‘ƒB*»¿BI&DBˆÝB«†ŒBÎ8BBî™.C/•Cí|B´8üB¡\'BË“ÑBדBìò•BêECDCBßòµBÐÆBʼêBàOùB¤lIB]šÊBDAbBBŽÅBG`lB:›2BEWDBbX@B%ÓBX_B•mžB‰ŒBBÞ?BFW±Bmo&Bq‘B‹’+B†vÝBd˜­BFŽbBJùBWj(BLBB?f¸BVFxBE°½B=AäBLTóBG«BejÎB8ÿêB+tBMèæBL`wB]”ƒBIÃBOqTBI–›B²Ë5BÅW;B¦mîB˵ßBך”B“,ZC‰Dæ¢BƒÏ1Bb%Bu*B›]òB‘Bˆ¯DB}/;Bdp¢BAx»BI'B.5úBRæCBU9sBFdXBbŸ?BJÈaBqQBJìëBM‡CBuîBÒäUC xCÊ CzdBM!WBOÌB_\¢B7¯îB?ÐBKCuB<•BGôXBUSiB‚ò BÚZB’ñ8B‡]ÄB^1B.ÖBHsDBrmdB²4Bß"ðC6 B÷ÍÓBí BªB¤QÄB¤Ü:BÔðÙBï.BårÍBû :BîìFB¹æÀBÓBÈÛ–B´¼ByÓžBTóB.[zB<Ì•BEY BGäõBGLB8nPB”:ÔB•¥ B””Bf6µB[‚iBl!½Bh˜ñBx¤‚B­]BjBS•Boš9BjH¶B^ÙPBM›«B„”BK¹ BØ?B2ÓB2ÝBNP BbI*B8º\B9˜öBDùøBrl¸B¸sÌBÉØB‘l¾BÏèéBÅ]fB×eAD ‚DÂÕ”Bp2SBïmB”Ž>B’À9B”\¹B„HbB$‹BbxßBZe‘BU\&BK¯Ì4Bj³™B,›Bˆ–NB‘êGB‚¾'B‡U'BAø³B.BIŸB»F·Bô€2Bû‘ÏBBð¢LB¨4„B•_BÁØqBÞÆ¬BëÙÈB×åŸC8Bî§BÏ“ÑBÎÕêBÊÚ°Bš±dB€ íBBádB%“}B0ý™BCU½B3ƒÀBAænBB‚3XTENSION= 'IMAGE ' / Image extension BITPIX = -32 / array data type NAXIS = 2 / number of array dimensions NAXIS1 = 200 NAXIS2 = 150 PCOUNT = 0 / number of parameters GCOUNT = 1 / number of groups EXTNAME = 'SKYFIT ' / extension name END Ay[ËA‰†ûAf-¶>ÌndÀ¢Z?ÊÈ1@ÀN_@Ã!Ž@ªŠ@ž7}?Cð…Àš‘ÀÇç=ÀÕ ØÀÇOÿÀ˸ZÀó{‰Àÿ»ŸÀøðÀôßÁÁ$ú³Á?ŠDÁ<¥‹Á9)îÁ5Á%îÁ2ºOÀï.ÒA‹9BGBóˆB 6@Bl‡A£1bÀqcðÀ×A¿™ôæA08ÆA+ù¾A?C‹A`ìƒAf'q?Ú'À‘"ÚÀˆhÀ¦$“ÀÖÙxÀ”|ƒÀÀÁÀ‹'&À±–tÀ²ŽyÀ ñ÷À¶w’ÀÅ9ºÀ…îDAÖ"+B”TBžp'B˜|˜B›M®Bu«Ÿ@×öÀø(ÁÅ‚À­òAA}?ÈAã”áAÚ=.AÕÏAÒsÁAHD¬À2OÀ¿TõÀ¼’À¢¨æÀ¤‡ÒÀ¦—ÀÏuèÀ¸Ï€À‰Þ>Aè/ÙB°tBÝÆB×ð;B×± B¸^A™]ÀûÂ)Àæm}À»ñÀ¿†A=q0BdB þ×B™¥BŠúAÅüð¿ò"+ÀõàÀö1ôÀÿ§nÀµí¥Ay*ñB¡²†B»¤B¸ë@B¹4B¦ÕÊA°~ÈÁÿÁ&ÔçÁ7ÏÁ ÉÁ*þŸ¿êØdA/ïA¾·A¼±AËÚ­A«ƒ?ýª—Á€ïÁ„ôÁNîÁŸÁ…µ¿äù@Ÿ©Þ@Ø%MAc @Óu?@aÀ÷y×ÁçÀÂÁA·?¢BšõB*;ìB5z9B=ÁÞB âhBžS/C¢qC¾[C+CÀ7B¨švA ÔÁ'Á½(Á)âÁ¥sÁˆÀùm?Á>7Á(îÁ3QÁ6ŸžÁXþeÁJÊ}Á*mÁLHÁ.†ÁTÀǨß@ÈãlA'€²A&´ÚA1÷‡A€ À5 ÃÁ¹@ÀÆÜšA·‰†BF¦ÈB}ÖB€ÆgB{]ªB3Ð^ëÀ¡òµ?Êýz@À5@Ã!@ª©@žL½?EÍ”À™ÙÂÀLjéÀÔÉäÀÇ0ÀË]ÿÀòìòÀÿ6mÀøw¤ÀôSÁ1cÁ$£šÁ?0•Á<;íÁ8×KÁ52ïÁ%€uÁ2qXÀî¦A‹OÂB\þBµB BäBƒËA£a¿ÀoÛCÀÖ° ¿”B.A1‡A,‡mA?ПAazAfv–? ‡áÀ¿ÀˆCÿÀ¥™pÀÖ7ÂÀ”<¿À¿v¯ÀŠÜÆÀ°öŠÀ²ÖÀ eîÀµØlÀÄÞÀ…³ºAÖ@OB”!BBžzB˜ÏB›OßBuµÆ@Ø·¿ÀøÓÁj&À­A}B‰Aã£$AÚMAÕãVAÒ‰2AHh£ÀŽÉ$À¿0À¼]À¢À¤YÚÀ¥õÌÀÎÞõÀ¸'ÙÀ‰¨•Aè)CB°VBÝhB×ø3BײÊB¸`“A™˜´Àû‚ÃÀæ( À»ê½À¿%A=¢BXB B—B‹>AÅäì¿ïô­ÀôËãÀö)ÚÀÿbÏÀµàAyA:B¡©wB»…B¸é$B¹{ÜB¦ØÕA°ž¸ÁéÁ&³Á#-ÁùåÁ*Ð-¿éé€A=A¾Ê$A¼5ÏAËï­A«4,?ÿ¯`ÁH„ÁupÁÁ wÁhÖ¿äÖ@ @ØQAsõ@ÓªK@ÂØÀ÷UðÁëÜÀÁ•‡A·D¾B¡B*ÁóÁ'žµÁ2›pÁ6<×ÁX$ÁJ_ëÁ)øÁQ¾Á-ënÁ ÀÇf @É”A'™lA&ÒEA1þ A‹ãÀ4–åÁ‰yÀÆÑçA·ulBF¦,B}ÛÈB€ÌB{uWB3•¶A™ð¸AòßBD¶ÁBTÉB^ bB“qB‡÷¦BDÿeB+ñMB&nAñ¸X@¬ª4À· Á*,xÁ9¤¯Á#mcÁ+ôÁ.(Á"ä}Ay:\A‰€VAf7>ÔT?À¡ÅÀ?Ë3@À­@ä@ªÉa@žb@?G­²À™›·ÀÇ)ÇÀÔrÀÆßÓÀË Àò]5Àþ°À÷þÀóµÁħÁ$K™Á>ÕàÁ;Ñ>Á8ƒÓÁ4×–Á%<®Á2'¸Àî çA‹f2Br½BB O B›HA£’ŒÀnOWÀÖ”¿Ž‚ìA1åìA-¯A@_$Ab ÀAfÆD?*JŸÀ[kÀˆaÀ¥ ÀÕ”~À“ü…À¾ÍûÀŠ‘¼À°TÿÀ±üÀŸØŽÀµ8ÀÄ‚îÀ…x¡AÖ^ÔB”)BBž…&B˜ƒB›RBu¿ï@Ù{<À÷áDÁÀ­*ŸA}E_A㱌AÚ]AÕ÷ºAÒžÒAHŒáÀŽ_BÀ¿ ÙÀ¼'ˆÀ¢TóÀ¤+˜À¥ÒŒÀÎF¢À·~áÀ‰rjAè"ÙB°9BÝBØ;B×´B¸cA™ÔçÀûCDÀåã À»äcÀ¾®ÉA=ÊuBKB ;B”|B‹‰AÅÌ·¿íÂVÀôzFÀö!•Àÿ‡ÀµÒµAyXB¡ XB»uB¸çB¹x~B¦ÛÛA°¿ÁÁåÁ&áÁ„ÁæÚÁ*¡G¿è÷)AJkA¾ÝxA¼R0AÌÎA«K @ÜuÁ¥ÁeÅÁÙ•Á-ÁK®¿ä²A@ `ð@Ø}BA„Õ@Óß¾@v1À÷1{Áð¡ÀÁúA·IÕB§OB*<÷B5¢vB=àvB ã BžGÇC CÅ—C‘ CÀB¨°KA Á&ÅÁ›éÁ(ÁwÁmÁRÀùmÁ§:Á''|Á2ZÁ5ÙÁXÖÁIôoÁ)Ú‡ÁW=Á-ÏÁíÎÀÇ#@É:[A'²zA&ïðA2§A—2À4ßÁY[ÀÆÆÜA·a)BF¥œB}á~B€ÑãB{,B3œ7Aš×AòçBD´4BTÙB^(€B“ëB‡þBEÃB+úB&",AñÇú@­:zÀ¶o_Á)í Á9o)Á#QÈÁ*ÛEÁ.Á"Ä‚Ay)A‰|èAf;“>ØN`À¡˜{?Ëi @À@Ã@ªé[@žx?IÞÀ™]oÀÆÉ×ÀÔ6ÀƦéÀʧ„ÀñÌQÀþ(¦À÷ƒeÀóÁVâÁ#ò¯Á>z&Á;eÁ8/…Á4{xÁ$øXÁ1ÝqÀív“A‹|ÝBˆºB}B \tB²ÿA£ÃÈÀlÀ-ÀÕ‰¦¿ˆ· A2¾óA-§†A@ïAbšAg|?4"_ÀöEÀ‡ú:À¤rÀÔï®À“»ÕÀ¾#¤ÀŠFÀ¯±ÒÀ±#êÀŸIØÀ´–ˆÀÄ&«À…<øAÖ}»B”1RBžÂB˜†oB›TcBuÊ@Ú@‘À÷½nÁ±À¬ÅA}HKAãÀAÚm4AÖ BAÒ´¡AH±cÀô©À¾åGÀ»ñeÀ¢*ÁÀ£ý À¥®ÔÀͬïÀ¶Ô˜À‰;»AèœB°BݧBØTB×¶\B¸ewAšµÀû­À圹À»ÞÀ¾A{A=÷©B?B |B‘ÓB‹ÚAÅ´P¿ë‹'Àô( Àö%Àþ×”ÀµÅAyo„B¡—+B»#sB¸äåB¹uB¦ÞÛA°ßªÁš¢Á&nSÁùÒÁÓªÁ*qí¿è`AWÖA¾ðýA¼nÕAÌA«b@ãœÁÖRÁUóÁž2ÁûÂÁ.>¿ä@ ½™@Ø©ÍA•­@Ô˜@*mÀ÷ zÁõRÀÀ‘A·NéB­šB*=B5¶ÏB=ïÛB ãBžBCžøCÉDC‘üCÀ¦B¨»SA ›2Á&£!Á‹2Á(ŸêÁPÁ`cÀùl×ÁZØÁ&¯BÁ1šÁ5t[ÁW­{ÁIˆ Á)¼ÊÁ\ÃÁ-²OÁ×ÜÀÆß¯@ÉfÂA'ËÛA' ÜA2 UA¢ŽÀ3¥¯Á(æÀÆ»zA·L¿BF¥B}ç=B€×±B{¥(B3¢¿AšAòðBD±«BTé/B^0³B“eBˆ§BE1B,ñB&/Añצ@­ÌÀµÑXÁ)­ Á99Á#5ØÁ*´HÁ-ÛÁ"¤BAy‡A‰yiAf?é>ÜMOÀ¡jæ?ËŸQ@¿è0@Ã{@« Œ@žŽ ?KwÀ™ëÀÆiÀÓ¿}ÀÆmqÀÊKdÀñ:GÀý À÷ŠÀò•FÁèÁ#˜ÞÁ>fÁ:ø¯Á7ÚbÁ4“Á$³tÁ1’‚Àìà«A‹“ÃBž÷B)B i_BÊïA£õtÀk-ÄÀÔô?¿‚ÞÊA3™A.9ñAA€€Ac+ŽAgg=?>!À*À‡ÔŠÀ£ð—ÀÔIOÀ“z®À½w«À‰ù©À¯ À°¨¡Àž¹ËÀ³óËÀÃÉÖÀ…ÁAÖB”9sBžšqB˜‰ØB›V¶BuÔF@Û½À÷™SÁS`À¬^AA}KKAãÎÆAÚ}aAÖ ìAÒÊAHÖ,À‰ZÀ¾¿^À»º«À¢iÀ£Î8À¥Š¦ÀÍÝÀ¶(þÀ‰ŠAè‹B°BÝCBØ}B׸2B¸gâAšOÀúÃýÀåU®À»×˜À½Ó;A>%>B2B #ÇBBŒ2AÅ›¸¿éO ÀóÕ.Àö‹ÀþøÀµ¸tAy‡…B¡ïB»(€B¸âÂB¹q¯B¦áÖA±¬Ás<Á&KhÁåÁÀSÁ*B¿ç$Ae_A¿²A¼‹½AÌ/wA«yh@í$ÁœÁEúÁbUÁô6Á†¿äh@¡@ØÖ¹A¦}@ÔKÚ@ß‹ÀöæíÁùðÀÀ äA·SùB³ûB*>B5ËOB=ÿPB ä BžBE¯B, ãB&<Añç\@®^ÌÀµ2Á)lsÁ9gÁ#’Á*ŒþÁ-Á"ƒ»AyvA‰u×AfD>àQ À¡=?ËÕí@¿Î&@ÃÏ@«)ó@ž¤U?M`bÀ˜à+ÀÆ‘ÀÓd×ÀÆ3kÀÉî®Àð§ÀýYÀöŠˆÀòtÁx8Á#>%Á=¿ Á:ŠÏÁ7„jÁ3ÀèÁ$nÁ1FëÀìI/A‹ªæBµtB6ØB vcBãA¤'ŽÀi˜ÀÔ]_¿yóÓA4uêA.ÍðABWAc¾-Ag¸‰?HçÀ)À‡®PÀ£`ÀÓ¡dÀ“9À¼ÊÀ‰¬¡À®f“À°,!Àž(gÀ³OÚÀÃlnÀ„ÃúAÖ¼®B”A¥Bž¥3B˜QB›YBuÞs@ÛÐÁÀ÷tñÁôâÀ«öKA}NbAãÝšAÚ£AÖ5ºAÒàÈAHû:ÀSÀ¾™À»ƒYÀ¡ÕëÀ£ŸÀ¥fÀÌulÀµ|ÀˆÌ×Aè¦B¯íBÝÞBØ·B׺B¸jHAš"Àú„4Àå ëÀ»Ñ'À½dA>S3B%B -BŒWBŒ‘AÅ‚î¿çAÀó³ÀöÇÀþI²Àµ«”Ay B¡„£B»-œB¸àžB¹n?B¦äËA±" ÁK³Á&(!ÁÐWÁ¬×Á*Ü¿æ vAsA¿˜A¼¨éAÌDþA«ç@ù ÁbTÁ5ÚÁ%ÿÁì‰Áò†¿äA @¡y.@ÙA·D@Ô‚ƒ@•ŒÀöÀÓÁþyÀ¿‡\A·YBºpB*> B5ßöB>ÖB ä”Bž6ŽCœ´CнC“àCÀúB¨ÑžA °^Á&^GÁi‘Á(\ÁùÁÞÀùkêÁÀLÁ%»ÎÁ0“âÁ4§õÁVÇ¡ÁH¬Á)€ºÁgéÁ-wõÁ«›ÀÆUw@ÉÁkA'ÿšA'JvA2îA¹kÀ2¯ÖÁÆõÀÆ£­A·#pBF¤7B}òÐB€ãpB{Õ–B3¯äAš9ôAó”BD¬¦BU ÐB^AZB“ ZBˆåBE%>B,ëB&IAñ÷@®òÙÀ´‘YÁ)+CÁ8Ë+Á"üöÁ*eeÁ-*Á"bïAxöKA‰r2AfH*>äY“À¡Ë?Ì Þ@¿³ê@à @«J‘@žºà?OL»À˜¡.ÀÅ¥:ÀÓ EÀÅøØÀÉ‘aÀð¾Àü‹Àö ]Àñ˜‘ÁTÁ"â„Á=`ÕÁ:ÞÁ7-œÁ3bvÁ$(Á0ú«Àë°A‹ÂDBÌ/BD¼B ƒBûzA¤ZÀgÿ5ÀÓÅ¿nýA5SÚA/cƒAB§ŸAdQïAh ^?R'¯ÀŽÁÀ‡‡À¢Ï*ÀÒ÷ëÀ’öþÀ¼ÓÀ‰^îÀ­¾À¯®iÀ•¬À²ª¸ÀÃtÀ„†¥AÖÜ»B”IçBž°B˜ÛB›[}Buè¢@Ü›À÷PIÁ•›À«'A}QAãì’AÚûAÖJªAÒ÷"AI ŽÀŒ°–À¾r…À»KpÀ¡«GÀ£o²À¥@åÀË×›À´ÍØÀˆ” Aè îB¯ÖBÝvBØ!B×»öB¸lªAšËÁÀúDSÀäÅmÀ»Ê¯À¼óãA>ŠBB 6{B‰…BŒöAÅió¿äÈŠÀó-˜ÀõþØÀþÂÀµžàAy¹>B¡{IB»2ÇB¸ÞwB¹jÉB¦ç»A±CÁÁ$Á&|Á»Á™4Á)á&¿å UA€ÊA¿,®A¼ÆYAÌZ§A«¨œ@XÁ'¨Á%”Áé.Áä»ÁÔ=¿äb@¡Ø@Ù1µAÈ@Ô¹“@LoÀöš,ÁïÀ¿A·^BÀúB*?5B5ôÃB>lB å)Bž0ÈC›•CÔˆC”ÓCÁ'B¨ÜáA èféÀ àF?ÌD$@¿™{@ÃI@«kf@žÑ®?QÁ#árÁ0­ÄÀë{A‹ÙÞBã*BRÆB ³BA¤ÀfcÀÓ+7¿bA63mA/úªAC=WAdæ×Ah\¼?\SzÀŽXÀ‡`AÀ¢<—ÀÒLåÀ’´tÀ»iôÀ‰‘À­ÍÀ¯/yÀšÀ²bÀ¯æÀ„HÀAÖý)B”R;BžºðB˜”vB›]òBuòÓ@ÝhQÀ÷+ZÁ5ŒÀ«"ÔA}TÎAãû®AÚ®iAÖ_½AÓ ªAIF(ÀŒC"À¾K•À»ïÀ¡€}À£@À¥RÀË8jÀ´KÀˆ[çAèbB¯ÁBÝ BØ)\B×½åB¸oA› ûÀúYÀä|5À»Ä/À¼‚ÌA>°AB B ?äB†¥BcAÅPÆ¿â}úÀòØÝÀõõ¾Àý¹(Àµ’WAyÒöB¡qàB»8B¸ÜOB¹gMB¦ê¥A±eÕÁü5Á%à{Á¦¼Á…kÁ)¯ü¿äÂAެA¿@ôA¼ä AÌprA«À†@Áì‰Á&Á«äÁÜËÁµ­¿ãòK@¢7Æ@Ù_ÄAغ@Ôñ @5ÀörùÁRÀ¾xRA·cBÇ™B*?ÍB6 ¸B>.B åËBž*ÿCšyCØ^C•ÇCÁWB¨è8A ÉzÁ&3ÁG¯Á(hÁÜ–ÁÚzÀùjvÁ#`Á$ÄXÁ/ˆãÁ3צÁUÝ“ÁGÍMÁ)CãÁs/Á-<^Á~ßÀÅÇù@Ê‘A(4§A'ˆA2&ØAÐ{À1µXÁc§ÀÆŠ€A¶ù€BF£†B}þB€ï\B|£B3½#Aš_PAóBD§±BU*öB^RVB“!NBˆ_BE8B,':B&c¥Aò½@°ºÀ³LÁ(§Á8ZýÁ"ÂÀÁ*JÁ,Á" †AxÓ¨A‰j´AfOÙ>ìy À ±p?Ì{¿@¿~Ú@Ão@«Œq@žè¾?S.—À˜"€ÀÄÞ$ÀÒO\ÀÅ‚ÀÈÕÀîæ›ÀûrmÀõ ‘Àð——Á"nÁ"(‰Á< -Á9:ÊÁ6}Á2£@Á#šTÁ0`5ÀêyCA‹ñ´BúeB`ôB ÿB,êA¤ÀzÀdìÀÒï¿VA7¢A0“eACÔ€Ae|ãAh¯¥?f”HÀî2À‡8lÀ¡¨ÇÀÑ QÀ’quÀº·rÀˆÁŠÀ¬ixÀ®¯SÀœl2À±\ÚÀÂPÆÀ„ MA×øB”ZŸBžÅëB˜˜!B›`qBuý@Þ6ÝÀ÷&Àÿ©hÀª·RA}X%Aä îAÚ¾ìAÖtôAÓ$`AIlÀ‹ÔöÀ¾$MÀºÙ×À¡UÀ£À¤õIÀÊ—ÚÀ³mmÀˆ"«AèB¯®BÝ¡BØ1ÇB׿ÛB¸q^A›JÐÀùÄGÀä2DÀ»½§À¼ÂA>ßXBýB IWBƒ·BÖAÅ7h¿à.“Àòƒ„ÀõìzÀýoåÀµ…úAyí@B¡hhB»=GB¸Ú%B¹cÌB¦íŠA±ˆDÁÔAÁ%¼Á‘âÁq{Á)~^¿ã¼Aœ¬A¿UlA½Ă_A«Ø¦@+Á°÷Á’Án ÁÔºÁ–Ô¿ãÉZ@¢˜3@ÙŽ3Aéi@Õ(ë@¼ÝÀöK9Á  À½îÐA·hBÎMB*@iB6ÔB>=ÉB æzBž%1C™_CÜ?C–¼CÁˆB¨ó¢AWƒÁ%ô³Á6¥Á'ôµÁ¿Á¸tÀùi‰Á ÔÁ$GÁ/–Á3nÁUfúÁG\TÁ)%-ÁxßÁ-ÁhRÀÅÿ@ÊNA(O«A'§AA2-ëAÜÀ16\Á1}ÀÆ}fA¶äLBF£?B~eB€õbB|dB3ÃÍAšr.Aó¡BD¥ðüÀ ‚J?̳®@¿d@Ã…@«­³@Ÿ?U$À—âÎÀÄyeÀÑñÀÅEÌÀÈuóÀîNÐÀúä1ÀôŠïÀð€Á®lÁ!Ê0Á<>PÁ8ȧÁ6$3Á2B{Á#R¨Á0þÀéÛwAŒ ÅBßBoFB «cBEùA¤ôRÀc! ÀÑó.¿IÒA7÷{A1-´ADmAfAi?pêÀƒPÀ‡À¡¹ÀÐò0À’-þÀºNÀˆqÙÀ«¼€À®-õÀ›ÕsÀ°´ÀÁñÀƒËJA×?*B”cBžÐùB˜›ÝB›büBv8@ß@Àöà«Àþæ'ÀªJ¢A}[AäSAÚÏ…AÖŠMAÓ;EAI’-À‹fÀ½ü®Àº (À¡*xÀ¢ßÄÀ¤ÎÉÀÉõëÀ²»?À‡èìAçúÐB¯œBÝ3BØ:CB×ÁÚB¸s²A›‹@Àù„Àãç™À»·À»ÆA?ÑBðB RÔB€»BŽOAÅÙ¿ÝÚSÀò-ŠÀõã Àý%øÀµyÉAzB¡^áB»BžB¸×øB¹`DB¦ðiA±«Á¬*Á%—bÁ}Á]fÁ)LL¿áöDAªÊA¿jA½ >AÌœnA«ðü@@~ÁtñÁó×Á/âÁ̈Áw³¿ãŸ@¢ùa@Ù½Aú@Õa1@ vhÀö"ìÁÛÀ½cúA·mBÕB*AB64B>MB ç5Bž_C˜HCà)C—²CÁ»B¨ÿAæ‡Á%ÐåÁ%‹Á'ÑÆÁ¡hÁ–7Àùh{Á „Á#ÈâÁ.yÁ3nÁTïTÁFêqÁ)EÁ~–Á,ÿŠÁQ§ÀÅ75@Ê~4A(kA'ưA25Aç¾À0¶7ÁþüÀÆoôA¶ÎïBF£B~ QB€ûtB|8MB3Ê~Aš…+Aó%àBD¢ËBUL¡B^c¨B“"CBˆ-BELB,9ßB&~¨Aò6†@±O¥À²žÁ( Á7è‡Á"‡3Á)ÃøÁ*žÁ!ÝAx°žA‰bìAfVø>ô«¹À RÔ?Ìëò@¿I@ÂüŒ@«Ï,@Ÿ¤?W®À—¢áÀÄØÀÑ‘ÁÀÅ ÀÈLÀíµÞÀúTÔÀô&Àï’XÁ9`Á!jïÁ;ÛnÁ8UsÁ5ÊÁ1àñÁ# mÁ/ÃÀé<AŒ"B)˜B}¾B ¸ßB_@A¥(™Àa{'ÀÑTõ¿=ŠÛA8ÛöA1É—AE%Af¬hAiW?{TìÀ{À†ç&À }oÀÐBÀ‘êÀ¹MˆÀˆ!~À« èÀ­«_À›=^À° 2ÀÁÍÀƒ‹¸A×`½B”kšBžÜB˜Ÿ©B›e’Bvm@ßÙ{ÀöºëÀþ!UÀ©ÜÂA}_Aä)ÛAÚà3AÖŸÉAÓRYAI¸˜ÀŠö{À½Ô·ÀºeàÀ ÿ<À¢¯7À¤§ÒÀÉRœÀ²¿À‡®«AçõÊB¯ŒBÝÃBØBÏB×ÃâB¸vA›ÌKÀùCÙÀãœ4À»°À»)ØA?>ªBãB \\B}²BŽÏAÅ¿Û;ÀñÖñÀõÙrÀüÛaÀµmÂAz#B¡UKB»HB¸ÕÊB¹\¶B¦óCA±Î4ÁƒïÁ%rKÁhÁI+Á)Ç¿àèYA¹A¿~ìA½>¼A̲žA¬ ˆ@ XMÁ8xÁâõÁñ+ÁÄ4ÁXJ¿ãtí@£[O@Ùì5A ®@Õ™ß@!0ÕÀõúÁÀ¼×ÐA·r BÛóB*A«B6IB>]hB çýBžŠC—3CäC˜¨CÁðB© °AvˆÁ%¬ÉÁaÁ'®Áƒ…ÁsÂÀùgKÁ 3ŠÁ#I¦Á-ï`Á2—ÛÁTv¡ÁFw¤Á(ç,Á„VÁ,àªÁ:ÜÀÄí˜@Ê®óA(†¯A'æ`A2øÌCÀ #?Í$‹@¿-È@Âøƒ@«ðÛ@Ÿ/z?YOÀ—b¶ÀíÀÑ1’ÀÄ˪ÀǶÀíÅÀùÄUÀó„5ÀïÁÃIÁ! ÆÁ;w†Á7á/Á5oÁ1~ŸÁ"Á¤Á/s˜Àè›"AŒ:›BABŒZB ÆsBxÁA¥]PÀ_ÒÀеC¿1*ŸA9ÂA2gAE¢ AgEâAi«—?‚êaÀŒª°À†½¶ÀŸåçÀÏ‘EÀ‘¥¯À¸– À‡ÐxÀª]­À­'“Àš£ñÀ¯_ÀÁ/ôÀƒK—Aׂ±B”t1BžçNB˜£†B›h4Bv¤@à­ŽÀö”äÀýZñÀ©m´A}b¨Aä9ˆAÚð÷AÖµhAÓišAIßHÀІ,À½¬hÀº+À ÓÚÀ¢~aÀ¤€dÀÈ­íÀ±RïÀ‡sçAçððB¯~BÝQBØKlB×ÅòB¸xJAœ ñÀù}ÀãPÀ»©ãÀº´øA?näBÕB eíBz›BVAÄê%¿Ù#KÀñ¹ÀõÏ®Àü ÀµaèAz?ŽB¡K¦B»MvB¸Ó™B¹Y#B¦öA±ñµÁ[Á%LÖÁS&Á4ÉÁ(æÍ¿ßÖûAÇ`A¿“õA½]~AÌÈñA¬"I@ r}ÁûŒÁÑìÁ±ùÁ»¿Á8™¿ãIp@£½þ@ÚÇAD@ÕÒõ@!ì$ÀõЮÁÀ¼JTA·wBâåB*BQB6_B>mPB èÑBž°C– CèC™ŸCÂ(B©UA„Á%ˆ^Á&Á'‹9ÁeoÁQÀùeùÁ âhÁ"ÉjÁ-dwÁ2+MÁSüâÁFíÁ(ÇáÁŠÁ,Á{Á#òÀÄ£+@ÊàRA(¢¯A(QA2CœAÿ3À/²rÁ˜óÀÆTA¶£½BF¢¶B~>BºB|j–B3×ôAš«…Aó8µBDöBUnÒB^uOB“#7Bˆ;BE_îB,LÙB&š$AòVx@²…šÀ°±àÁ'—ÀÁ7sÊÁ"JQÁ)qnÁ(ÃÁ!˜oAx-A‰ZÜAf]…>üñšÀŸòø?Í]y@¿^@Âôj@¬Á@ŸG’?[ÿÀ—"PÀÃFXÀÐÐvÀÄÅÀÇU9À쀆Àù2¶ÀòÿÀîˆÓÁL)Á ©´Á;™Á7kÚÁ5KÁ1ˆÁ"xMÁ/#iÀçøšAŒS`BYÈB›B ÔB’{A¥’vÀ^%©Àп$±NA:©ÕA3AF?ŒAgà€Aj¦?ˆ4ÎÀŒ<òÀ†“¼ÀŸM!ÀÎÞ|À‘`ÖÀ·ÝÀ‡~ÉÀ©«ÑÀ¬¢ŽÀš .À®²ÀÀÀΈÀƒ çA×¥B”|ÙBžò•B˜§tB›jàBv%Ü@áƒxÀön—Àü’ýÀ¨ývA}fTAäIYAÛÐAÖË*AÓ AJ?ÀŠ%À½ƒÂÀ¹ïŒÀ ¨RÀ¢MAÀ¤X€ÀÈßÀ°œÍÀ‡8 AçìBB¯qBÝÞBØTB×È B¸zAœP3ÀøÃÀã>À»£=Àº?%A?ŸBÇB oˆBwvBäAÄпÖÀƒÀñ'áÀõÅ¿ÀüD6ÀµV8Az\#B¡AòB»RùB¸ÑgB¹U‰B¦øçA²‘Á3Á%'Á>-Á AÁ(³_¿ÞÂ+AÕ×A¿©.A½|„AÌßeA¬;?@ Á¾,ÁÀ½ÁrNÁ³)Á ¿ã@¤!n@ÚKºA+Ò@Ö q@"¨VÀõ¦»ÁÀ»»ƒA·{óBéìB*BúB6tÉB>}IB é²Bž ÒC•Cì&Cš—CÂaB©"A™}Á%c¥ÁñÛÁ'g›ÁG&Á.1Àùd†Á ®Á"H.Á,ØZÁ1½ÅÁS‚ÁELÁ(¨eÁîÁ,¡ýÁ êÀÄWë@ËPA(¿A(&‚A2KA À/.ÒÁelÀÆEŽA¶çBF¢¡B~@B îB|ƒöB3Þ¹Aš¾áAóBLBD›‘BU€B^~BB“#±BˆBBEiïB,VvB&¨Aòf€@³"xÀ° Á'RoÁ78Á"+_Á)G´Á'°Á!u¼Ax{NA‰V¹Af`–?ßÀŸÂ’?Í–»@¾öÀ@ÂðB@¬4Ý@Ÿ_í?]¾À–á­ÀÂÞdÀÐnmÀÄORÀÆóÎÀëä!ÀøŸõÀòxÛÀîwÁÓþÁ G»Á:¬¥Á6õuÁ4¶¨Á0·ªÁ".gÁ.Ò’ÀçT~AŒl`Br?BªB áãB¬nA¥È À\v ÀÏqv¿êA;“9A3¦¹AFÝèAh|CAjV>?‰¼À‹Î>À†i9Àž³ÀÎ*%À‘‡À·"hÀ‡,oÀ¨øSÀ¬SÀ™mÀ®;ÀÀlŠÀ‚ɨA×ÇÀB”…‘BžýïB˜«rB›m˜Bv0@â[;ÀöHÀûÉwÀ¨Œ A}jAäYOAÛ¿AÖáAÓ˜©AJ-{À‰£gÀ½ZÄÀ¹³~À |¤À¢ØÀ¤0%ÀÇ`rÀ¯å[À†üÖAççÁB¯eBÝhBØ\ØB×Ê*B¸|ÏAœ“Àø‚{À⵬À»œÀ¹È`A?ÐzB¹B y-BtCByAĵ¬¿ÔXãÀðÏjÀõ»¦Àû÷¢ÀµJµAzyIB¡8/B»XŠB¸Ï3B¹QêB¦û±A²9ÉÁ hÁ%×Á),Á “Á(}¿Ý©èAälA¿¾˜A½›ÍAÌõüA¬Tl@ ®Á€ZÁ¯fÁ2)ÁªrÁø^¿âïë@¤…ž@Ú|ARB ê BžñC”Cð9C›CœB©-ÚA,rÁ%>žÁàÁ'CÁÁ(©Á ÀùbñÁ >\Á!ÅñÁ,K Á1OCÁS=ÁEÁÁ(ˆ¶Á•ÇÁ,‚/ÁõÃÀÄ Ú@ËDíA(ÛªA(FôA2RwAÛÀ.ª Á1ÀÆ6¼A¶wéBF¢˜B~"JB.B|}B3å…AšÒ]AóLBD™1BU‘ˆB^‡KB“$+BˆI6BEtB,`)B&¶Aòv’@³À™À¯\ãÁ' †Á6üÅÁ" Á)¬Á&„Á!RÂAxiUA‰RƒAfc‚?¥XÀŸ‘Ü?ÍÐS@¾Úñ@Âì @¬W0@ŸxŠ?_‹À– ÎÀÂu£ÀÐ yÀÄRÀÆ‘ÌÀëF”Àø ÀññsÀí{ ÁZÉÁäÚÁ:E¬Á6}ÿÁ4Y0Á0SÁ!ãóÁ.Àæ®ÍAŒ…œBŠöB¹ B ï¿BÆ›A¥þÀZÃ/ÀÎÍ\¿ spA<~@A4HíAG}¶Ai*Aj¬`?’é+À‹^—À†>,ÀžÞÀÍtAÀÕÁÀ¶fÀ†ÙkÀ¨C4À«”àÀ˜Ï¤À­V„ÀÀ ùÀ‚‡ÚA×êÚB”ŽZBŸ \B˜¯€B›p[Bv:Q@ã4ÕÀö!*Àúþ`À¨oA}mëAäihAÛ#ÄAÖ÷AÓ°vAJTýÀ‰0óÀ½1nÀ¹vÙÀ PÑÀ¡ê&À¤TÀÆ·¥À¯,˜À†À‰AçãlB¯\BÝðBØe¦B×ÌRB¸ AœÖ†ÀøAÕÀâg`À»•ÚÀ¹P©A@×B«B ‚ÜBqB‘AÄ›%¿ÑìkÀðvSÀõ±cÀûªdÀµ?\Az—B¡.]B»^)B¸ÌüB¹NEB¦þuA²^[ÁáŸÁ$ÚLÁ#Áö¿Á(K'¿ÜŽ3AóA¿Ô3A½»ZAÍ ´A¬mÎ@ ÏVÁBÁéÁñ‹Á¡™Á×Õ¿âÁâ@¤ê@Ú¬ÃALÔ@Ö€¡@$#bÀõQ1Á#ÚÀº™èA·…ÌBø8B*DXB6 ®B>kB ë›Bž C’öCôWCœ‰CÂÚB©9¹AÀcÁ%HÁÏÁ'­Á úÁçÁÀùa:Á ësÁ!BµÁ+¼…Á0߯ÁR‰XÁD£KÁ(h×Á›§Á,bÁÞ|Àþø@Ëx*A(ø¥A(g¦A2ZA"ÂÀ.$ÁýWÀÆ'’A¶aÃBF¢›B~(ZBxB|·+B3ìWAšåùAóUÒBD–ÔBU£B^iB“$¥BˆPeBE~"B,iñB&Ä?Aò†¯@´_üÀ®°mÁ&ÆÁ6ÀgÁ!ì|Á(óVÁ%@Á!/‚AxWCA‰N­•B ì¢Bü!C‘íCø~CƒCÃB©E¬AUPÁ$ó£Á½—Á&û^ÁëÁÄ5Àù_bÁ —ñÁ ¾xÁ+,ÌÁ0oOÁR fÁD+ìÁ(HÅÁ¡Á,A§ÁÇÀÃqD@ˬA)ôA(ˆ™A2a£A.µÀ-œüÁÈÊÀÆA¶KtBF¢ªB~.sB ÎB|ÑB3ó1AšùµAó_ÁBD”{BU´ÂB^™B“%BˆW¢BEˆTB,sÏB&Ò„Aò–Ö@µ¢À®§Á&~ñÁ6ƒxÁ!ÌŠÁ(ȲÁ#ãÁ! ýAxEA‰IâAfhî?Û}ÀŸ/?ÎD€@¾¢º@Âãl@¬œz@ŸªŠ?c0RÀ–[ÀÁ¡¸ÀÏBËÀèÀÅÌÀêÀöàëÀðß+ÀìhúÁeBÁ`Á9tªÁ5‹áÁ3›ÀÁ/‡kÁ!M`Á-ÜÀå^°AŒ¸ÈB½!B×B ÀBû A¦kfÀWSºÀÍ€½¾ã¢A>Y6A5’AHÁ¢AjVfAkZB?ÇŽÀŠ|jÀ…æxÀœÝ§ÀÌÐÀHÓÀ´è•À†1eÀ¦ÔÀª‚TÀ—¾À«õ}À¿CÀ‚‘AØ23B” BŸ oB˜·ÏB›vBvNÌ@äíÀõÒ¥Àùc~À§0­A}uÙAäŠAÛF A×#‘AÓà›AJ¤ÑÀˆIåÀ¼Ý¼À¸ûÉÀŸø¸À¡…åÀ£´LÀÅaìÀ­·À†FhAçÛHB¯MBÝúBØwuB×нB¸ƒtA_EÀ÷À?ÀáÈœÀ»ˆYÀ¸^dA@e±BB –YBjYB’^AÄeƒ¿ÍòÀïÂFÀõœ\Àû ëÀµ).AzÔ,B¡ŒB»i”B¸ÈŠB¹FéB§íA²¨“Á¢Á$Œ!ÁéùÁ̤Á'á ¿ÚLqAžßA¿ÿùA½û>AÍ:‹A¬¡3@!ÁÄ/ÁzzÁnàÁ„Á•é¿âcD@¥¶´@ÛOAm¶@Öön@%¡÷ÀôùtÁ+PÀ¹rÿA·–B×B*EÃB6Í.B>½ÐB í¶Bö4CæCü°Cž~CÃ[B©Q³Aë9Á$ͱÁ¬ Á&ÖÔÁÌÁ rÀù]hÁ C×Á 9;Á*›àÁ/ýÞÁQŒhÁC³¢Á((‚Á§€Á, ìÁ¯“ÀÃ"¿@ËàA)3—A(©ÍA2iWA:µÀ-¸Á“æÀÆ7A¶4ýBF¢ÅB~4“B'/B|êÿB3úA› AóiÍBD’'BUÆ’B^¢æB“%˜Bˆ^îBE’–B,}ÂB&àçAò§@µ¢ŠÀ­SÁ&7DÁ6E÷Á!¬CÁ(ÀÁ"mÁ è2Ax2ÐA‰EvAfkm?ú)ÀžýØ?Î@¾†S@Âß@¬¿q@ŸÃí?e>KÀ•ÜÇÀÁ6ÀÎÝÀÃOþÀÅh?ÀégÀöI¥ÀðTKÀëÞXÁèïÁ¶ÆÁ9  Á59Á3;ÈÁ/ tÁ!AÁ-ˆ¦Àä´CAŒÒ·BÖ•BçB äByA¦¢¸ÀU—"ÀÌØ9¾ÉµA?I&A68ÿAIeÂAjö»Ak²?£FÀŠ äÀ…¹ÐÀœ>¯ÀËIDÀ«À´'_À…ÜbÀ¦ À©÷;À–ïJÀ«C.À¾ÞÔÀ¿AØVrB”©BŸ,B˜¼B›xçBvY @å̱ÀõªùÀø“³À¦º…A}yïAäšAÛWRA×:AÓøôAJÍ$À‡ÕLÀ¼³`À¸½]ÀŸÌrÀ¡SVÀ£ŠÀĵÀ¬úiÀ†”Aç×xB¯HBÝ|BØ€uB×ÒþB¸…¡A¤À÷PÀáx#À»À·ãÖA@˜0BB  &BfïB“ AÄJh¿Ê‰ñÀïgQÀõ‘˜Àú¾¯ÀµXAzóB¡B»o`B¸ÆMB¹C2B§¡A²Î7ÁfoÁ$dÁÔØÁ·^Á'«n¿Ù&dAžìAÀ&A¾–AÍQ©A¬»5@A™Á„ÁhˆÁ,ÔÁ†HÁt‡¿â2¯@¦ç@ÛA&A~@×1ð@&b•ÀôÌÃÁ.íÀ¸ÝA·”uBFB*F~B6ã¨B>ÎB îÖBðBCâCíCŸyCÞB©]ÍA‚Á$§pÁšnÁ&²Á¬»Á|wÀù[MÁ ï%Á²ýÁ* ¿Á/‹rÁQ ]ÁC:nÁ( Á­yÁ+ÿãÁ—ïÀÂÓh@Ì™A)QA(ËAA2qAFÂÀ,‹KÁ^ªÀÅøA¶^BF¢íB~:ºB-›B}$B4ùA›!‹AósöBDÖBUØ‚B^¬DB“&BˆfJBEœéB,‡ÊB&ïhAò·C@¶E´À¬£*Á%ïÁ6ãÁ!‹§Á(rÁ ÞÁ Ä"Ax qA‰@øAfmÉ? <ÀžËá?κ@¾iº@ÂÚ@¬âž@ŸÝ’?gOSÀ•š÷ÀÀʘÀÎvkÀÃÇÀÅâÀèÄáÀõ±>ÀïÈDÀëR¥Ák’ÁPEÁ8ŸÁ4•Á2ÚûÁ.¸¶Á ´“Á-4‡ÀäCAŒìâBðIBö£B ( B1ŠA¦ÚyÀS×KÀÌ.=¾¯•~A@:¸A6áƒAJ RAk˜5Al I?¨ÏöÀ‰–kÀ…ŒŸÀ›žyÀÊ*Àº À³d‡À…†¶À¥^eÀ©jëÀ–L~Àª¬À¾y÷À{ AØ{B”²(BŸ7ÎB˜ÀaB›{ÖBvcL@æ­ªÀõƒÀ÷ÂWÀ¦C/A}~Aä«7AÛh­A×P•AÔzAJõ½À‡_üÀ¼ˆ¬À¸~ZÀŸ À¡ ~À£_jÀĶÀ¬HÀá&ðÀ»z¹À·hVA@ËBrB ©ýBcxB“ÃAÄ/¿È Àï ¼Àõ†ªÀúnÊÀµ®A{ B¡B»u:B¸ÄB¹?uB§ OA²ô7Á=Á$<‚Á¿¯Á¡ñÁ'uI¿×üåAž/AÀ,‚A¾<1AÍhéA¬Õn@lrÁD|ÁVoÁêNÁ|êÁRÝ¿âA@¦…Ú@Ûs^AŽx@×mÙ@'$ÀôŸ†Á2wÀ¸FÈA·™QBÉB*G=B6úJB>ÞvB ðBêMCŽàC3C vCÃäB©iûAÁ$€àÁˆÀÁ&ÁAÁXDÀùYÁ ™ÜÁ+¿Á)vkÁ/ ÁP‹FÁBÀPÁ'çfÁ³zÁ+ÞŠÁ€-Àƒ?@ÌKRA)o×A(ìöA2xûARÛÀ,¶Á)ÀÅç}A¶–BF£!B~@éB4B}qB4çA›5¥Aó~=BDŠBUê”B^µ¸B“&ŒBˆm´BE§LB,‘çB&þAòLj@¶ê!À«ñtÁ%¦%Á5É>Á!jµÁ(FóÁ6Á ŸÌAx ÷A‰¶Àž™›?Îõ@@¾Lî@ÂÖ @­@Ÿ÷z?iciÀ•XêÀÀ]ÕÀÎÙÀÂÍÀÄžïÀè!”ÀõµÀï;ÀêÅàÁí*ÁèÜÁ83{Á4¸Á2yXÁ.P3Á gWÁ,ßÀÀãZ®AIB =BeB 6tBLÖA§ªÀR5À˂Ⱦ•C¿AA-íA7‹›AJ²SAl:ÓAlc?®cìÀ‰!üÀ…^åÀšýÀÉσÀq÷À²  À…0_À¤¡À¨ÝcÀ•¨\À©Ú÷À¾ˆÀ6rAØ B”»EBŸCšB˜ÄÂB›~ÑBvm@ç{ÀõZÏÀöïjÀ¥ÊªA}‚]Aä¼AÛzA×gLAÔ*/AK›À†éöÀ¼] À¸>ÀÀŸsuÀ í]À£4FÀÃW À«} À…‹bAçÐ_B¯BBÝ{BØ’§B×ךB¸‰îAž0îÀöý'ÀàÕÀ»sÞÀ¶ëãA@þOBdB ³ÞB_òB”€AĿŅhÀÀõ{’Àú<Àµ /A{45B ücB»{#B¸ÁÏB¹;²B§ øA³“ÁÁ$'Áª~ÁŒ^Á'>¯¿ÖÏòAž>^AÀCA¾]AÍ€KA¬ïÜ@™¬ÁöÁD0Á§OÁskÁ0ê¿áÎù@¦î@Û¥÷AžÌ@ת*@'æyÀôq»Á5íÀ·®°A·ž)BbB*GþB7B>îáB ñ=BäSCáC „C¡sCÄ+B©v=A²ÞÁ$ZÁwÁ&gÕÁm“Á3ÚÀùV°Á CúÁ£Á(áãÁ.£¬ÁP "ÁBEHÁ'ÆŽÁ¹„Á+¼âÁhLÀÂ2E@Ì©A)ŽuA)ëA2€ëA_À+t÷Áó,ÀÅÖœAµð¦BF£aB~G B:•B}9åB4ÛA›IßAóˆ¡BD‹ABUüÇB^¿AB“'Bˆu.BE±ÀB,œB' ÅAòר@·ÑÀ«>nÁ%\²Á5ŠÁ!ImÁ(ÁuÁ {0AwûdA‰7ÅAfr?d–Àžg?Ï0Ô@¾/ð@ÂÑv@­)œ@ ¤?kzŽÀ•¡À¿ðCÀͦZÀаÀÄ9fÀç} Àô} ÀÀê8 Ám¹Á€‹Á7Æ`Á3šÞÁ2àÁ-æèÁ ŒÁ,ŠRÀâ«…A!ìB$oBKB DáBhZA§KJÀPMàÀÊÕÛ¾u®AB"ÅA87FAKZÄAlÞ•Al¼x?´dÀˆ¬šÀ…0¡ÀšZWÀÉNÀ)kÀ±ÙñÀ„Ù^À£â3À¨N¤À•ãÀ©%À½®†À€ñJAØÅzB”ÄsBŸOyB˜É4B›×BvwÓ@èu$Àõ2QÀöëÀ¥PöA}†³AäÌøAÛ‹£A×~&AÔCAKG¿À†s8À¼2<À·þŽÀŸF¾À ¹óÀ£¬À¦Àª¼aÀ…LAçÍB¯BBÜÿ÷BØ›ÙB×ÙôB¸Œ AžxÀö»îÀà‚]À»lüÀ¶n~AA1ðBUB ½ÊB\`B•CAÃ÷î¿ÂûßÀîR´ÀõpOÀùÍÀ´þÜA{U]B ò7B»B¸¿ŒB¹7éB§›A³AIÁéþÁ#ëoÁ•FÁv¥Á'¢¿ÕŸŽAžMÄAÀYÎA¾~3AÍ—ÎA­ €@ÉGÀÿ…úÁ1ÊÁcÕÁiËÁ°¿á›Ø@§X@ÛØñA¯@׿á@(©¿ÀôCdÁ9OÀ·CA·¢ýB%B*HÄB7(B>ÿ]B ò„BÞVCŒäC ÞC¢qCÄuB©‚’AL·Á$2ÖÁe4Á&B`ÁM²Á8ÀùT0Á í€ÁCÁ(L'Á..RÁO…ñÁAÉUÁ'¥„Á¿•Á+šëÁPLÀÁàz@̸ A)­gA)1!A2ˆïAk4À*èÁ¼êÀÅÅbAµÙŽBF£®B~M^BA#B}TB4×A›^9Aó“"BDˆüBVB^ÈßB“'Bˆ|¶BE¼CB,¦cB'¡Aòè2@¸6ÃÀªŠÁ%©Á5J>Á!'ÐÁ'îîÁœÁ VNAwè·A‰3Aft?ŒÜÀž4?Ïl½@¾¿@ÂÌÑ@­Mn@ ,?m”ÂÀ”ÔÀ¿åÀÍ<ïÀÂGÐÀÃÓEÀæ×…ÀóáAÀî?Àé©#Áí>ÁRÁ7X?Á3ôÁ1³“Á-|ØÁË3Á,4;ÀáúÈA<ÊB>áB&WB SeB„A§„ZÀN„MÀÊ'u¾@AC@A8ä†AL¦Amƒ|Am]?¹«]Àˆ6BÀ…ÕÀ™¶jÀÈOŒÀŽàjÀ±2À„³À£!§À§¾­À”\À¨m÷À½GñÀ€«“AØë@B”ͲBŸ[kB˜Í·B›„éBv‚@é[¤Àõ ŒÀõDÜÀ¤ÖA}‹ AäÞAÛ>Aו#AÔ\%AKq)À…ûÃÀ¼À·½ÄÀŸàÀ †?À¢Ü›ÀÁó˜À©úhÀ… &AçÉ÷B¯CBÜÿqBØ¥B×ÜWB¸Ž(Až¿¼ÀözœÀà.ýÀ»fÀµð'AAeòBFB Ç¿BX¿B– AÃÜ ¿Àm}Àíõ@ÀõdáÀù{!À´ô´A{wB çüB»‡ B¸½HB¹4B§9A³h[ÁÀ=Á#Â[Á€Á`ÆÁ&Ð ¿Ôk·Až]HAÀp¼A¾Ÿ™AͯtA­%Z@ûDÀÿ!Á=ÁâÁ` Á ì-¿ágÞ@§Â:@Ü KA¿[@Ø$@)mçÀôÁ<žÀ¶z„A·§ÍB,ÑB*IB7?B?êB ó×BØTC‹éCCC£pCÄÁB©ŽúAçÁ$ [ÁSVÁ&°Á-ŸÁê^ÀùQÁ –oÁÁ'µ6Á-·ýÁO´ÁALyÁ'„HÁůÁ+x¥Á8-ÀÁÜ@Ìð6A)Ì­A)S—A2‘AwsÀ*YÿÁ†QÀųÑAµÂMBF¤B~S£BG½B}oDB4ÚA›r³AóÁBD†¼BV!’B^Ò“B“'ùBˆ„NBEÆ×B,°ÁB'*šAòø–@¸Þ÷À©ÔsÁ$È Á5 ãÁ!ÞÁ'ÂwÁªÁ 1'AwÕðA‰.IAfuÌ?·ŠÀžå?Ϩû@½õ\@ÂÈ@­qu@ F¾?o²À”‘ZÀ¿ºÀÌÒ˜ÀÂbÀÃlŽÀæ0ÄÀóDUÀ팙Àé+Ák¸Á­1Á6éÁ2›ùÁ1OpÁ-Á|LÁ+Ý|ÀáHwAWäBY“B6‡B bB A§½ØÀL·{ÀÉw˜¾ CAD^A9“ZAL¯ùAn)ˆAmpÍ?¿^×À‡¾÷À„ÒÀ™?ÀÇ=ÀŽ–òÀ°HÒÀ„)^À¢_zÀ§-À“³íÀ§µªÀ¼àÉÀ€eLAÙgB”×BŸgoB˜ÒJB›ˆBvŒ`@êCüÀôà‚Àôm;À¤ZA}¡AäïJAÛ®ïA׬CAÔueAKšÙÀ…ƒ˜À»ÚoÀ·|cÀžìÝÀ RAÀ¢°ÀÁ?ÏÀ©7À„ËÃAçÇB¯FBÜþéBØ®nB×ÞÂB¸>AŸ Àö91ÀßÚäÀ»_ÀµpÞAAšTB7B ѾBUB–ÞAÿú¿½ÚDÀí—-ÀõYIÀù(•À´ê·A{™dB Ý²B»5B¸»B¹0FB§ÒA³ÈÁ–WÁ#˜êÁj¼ÁJÀÁ&˜+¿Ó4mAžlêAÀ‡ÛA¾ÁCAÍÇÅÁÅÁ'Á-@®ÁN|jÁ@βÁ'bÛÁËÐÁ+VÁïÀÁ:n@Í(kA)ìFA)vNA2™4Aƒ¿À)ÊÅÁO`ÀÅ¡èAµªäBF¤kB~YñBNaB}Š.B4#ãA›‡LAó¨}BD„BV4)B^Ü\B“(rBˆ‹õBEÑ|B,»4B'9²Aó @¹ˆnÀ©}Á$|ÑÁ4ÈöÁ ã–Á'•²ÁŸÁ ¹AwÃA‰)qAfwr?äÀÍ^?Ïå@½×Ç@ÂÃZ@­•´@ a®?qÒVÀ”N\À¾¢ÁÀÌgTÀÁÀfÀÃAÀåˆÝÀò¦GÀìúËÀèˆ!Áé)ÁB'Á6xíÁ2íÁ0êxÁ,¦dÁ,ÖÁ+†Àà”’As:BtƒBFÛB p¶B¼?A§÷ÆÀJçkÀÈÆA½¨¨AE A:CÂAM\½AnйAmËÅ?ÅÓÀ‡F·À„¢ À˜j×ÀÆÉ`ÀŽMÀ¯}ÏÀƒÐ_À¡›¬À¦›À“ pÀ¦ü,À¼yÀ€vAÙ7ñB”àcBŸs‡B˜ÖîB›‹-Bv–©@ë.,Àô·1Àó” À£ÜÀA}”8Aå©AÛÀ¶A×Ã…AÔŽÔAKÄÎÀ… ¶À»®À·:kÀž¿´À úÀ¢ƒÀÀЧÀ¨r‚À„ŠÞAçÄ@B¯JBÜþ_BØ·ÑB×á5B¸’OAŸPõÀõ÷®À߆À»X&À´ð¢AAÏB(B ÛÇBQTB—¶Aã¶¿»B3Àí8{ÀõM†ÀøÕ_À´àæA{¼DB ÓZB»“YB¸¸¹B¹,lB§eA³·ÁlOÁ#oÁUlÁ4•Á&_Á¿Ñù±Až|ªAÀŸ*A¾ã0AÍß%A­[­@f`Àýú»Áù®Á–ÁL#Á ¦O¿àý]@¨˜è@Üt#AßÊ@ØŸu@*øßÀóµÁCÀµA A·±bB<“B*K)B7mºB?15B ö£BÌEC‰úC,C¥oCÅ^B©¨A -Á#»{Á/hÁ%РÁìßÁ ÀùKäÁæ„Áx†Á&ƒºÁ,ÈeÁMöÁ@PÁ'A<ÁÑúÁ+3,Á’ÀÀæ.@Ía?A* 4A)™FA2¡uAÀ):cÁÀŨAµ“SBF¤ÜB~`EBUB}¥@B4*óA›œAó³VBD‚GBVFáB^æ;B“(ìBˆ“«BEÜ0B,ŽB'HèAó~@º3(À¨e7Á$1Á4‡wÁ ÀùÁ'hŸÁ{ÁæAw°A‰$…Afxô?À™†?Ð"u@½¹ÿ@¾†@­º)@ |á?sõµÀ” "À¾1ûÀËû$ÀÁ{ÝÀÂ\ÀäßÏÀòÀìgÖÀçöÁeÁÖ6Á6»Á1˜ÑÁ0„«Á,:ÁÜÒÁ+.ÀßßAŽËB³BWUB ‚BبA¨2$ÀIÀÈs¼ë©åAFA:õ¾AN ñAoy An'H?ÊåPÀ†Í‚À„r7À—Ã2ÀÆöÀŽŸÀ®±)ÀƒvµÀ Ö;À¦}À’_œÀ¦AzÀ¼ÂÀ®$AÙ^ÜB”éÔBŸ²B˜Û¢B›Ž`Bv ó@ì3ÀôšÀò¹EÀ£^QA}˜äAå,AÛÒ’A×ÚëAÔ¨rAKï À„‘À»BÀ¶÷ÛÀž’dÀŸéjÀ¢U¡À¿ÔÀ§¬•À„IvAçÁ¨B¯PBÜýÓBØÁEB×ã±B¸”[AŸš{Àõ¶Àß0ƒÀ»Q$À´otAB;BB åÛBMŠB˜”AÇA¿¸¥IÀìÙ)ÀõA˜Àø€À´×AA{ßµB ÈòB»™‹B¸¶oB¹(‹B§òA³ß´ÁB"Á#DòÁ@ÁCÁ&&ä¿Ð»‚AžŒ‡AÀ¶ªA¿aAÍ÷1A­w(@Ÿ€Àýu/Áæ¬ÁQ.ÁAþÁ ‚ô¿àÆÖ@©_@ܨ Aïõ@ØÝË@+¿®Àó„‹ÁFÀ´¢PA·¶'BD“B*KüB7…FB?AòB øBÆ8C‰C°C¦pCŰB©´ªA½÷Á#“ÁXÁ%ª?ÁÌ2Áz‚ÀùHÜÁªÁëGÁ%é.Á,O!ÁMn°Á?ÐfÁ'lÁØ,Á+ùÁïÀÀ‘@Íš²A*,uA)¼~A2©ÊAœ}À(¨×ÁàyÀÅ}Aµ{šBF¥YB~f¡B[ÌB}ÀzB42 A›°ÝAó¾MBD€BVY»B^ð/B“)eBˆ›pBEæõB,Ð[B'XÁÀAwA‰ˆAfzR?EøÀe_?Ð_±@½œ@¹¤@­ÞÔ@ ˜U?v$À“ǬÀ½ÀgÀËŽÀÁ6ÇÀÂ4áÀä5šÀñfÉÀëÓ¸ÀçbÙÁàëÁi]Á5•„Á1¤Á0 Á+Ì×ÁŒ@Á*ÕPÀß( Aª˜B«#BgóB ŽgBõKA¨lðÀG=ŽÀÇ_,<ÌAcAGˆA;©NANº–Ap"‡AnƒT?иNÀ†SYÀ„AFÀ—PÀÅ<þÀ·ÄÀ­ââÀƒbÀ )À¥r©À‘³qÀ¥…–À»§áÀC§rCÆB©ÁaA\¾Á#j`Á 8Á%ƒ¤Á«SÁTÊÀùE³Á49Á]Á%MnÁ+ÔãÁLæ@Á?OáÁ&ýiÁÞgÁ*ìwÁÖ{ÀÀ;9@ÍÔÅA*M A)ß÷A2²3A¨ïÀ(#Á¨ƒÀÅjAµc¸BF¥ãB~mBb“B}ÛÛB49'A›ÅÕAóÉaBD}áBVlµB^ú8B“)ßBˆ£DBEñËB,ÛB'g®Aó:Ž@»ŒbÀ¦ð¼Á#—¡Á4ÄÁ z¾Á' ŽÁèÁ™ÐAw‰ÕA‰yAf{Œ?z@À0ç?ÐB@½}Ø@´±@®¶@ ´ ?xE¡À“ƒùÀ½NÀËÿÀÀñ"ÀÁËÐÀãŠ>ÀðÅXÀë>sÀæÎ›Á[>ÁûœÁ5"GÁ0‘gÁ/¶‘Á+^çÁ;Á*{òÀÞojAÆ¡BÆÑBx¶B cB'A¨¨,ÀEcÁÀÆ©l=¡ÓÎAH1A<^rAOk¬ApÍ%Anßê?Ö•ÎÀ…Ø;À„ËÀ–p0ÀÄtyÀlrÀ­øÀ‚ÁdÀŸFuÀ¤ÜžÀ‘ðÀ¤È€À»>nÀ~7AÙ­×B”üêBŸ˜AB˜å=B›”çBvµŒ@í÷ÊÀô9™Àðÿ À¢]æA}¢}Aå5ŸAÛöŠAØ AÔÜ7ALDPÀƒ›ÅÀ»&·À¶põÀž7TÀŸnÀ¡ùSÀ¾bñÀ¦ÊÀƒÅAç¼üB¯`BÜüµBØÔ^B×èÁB¸˜fA /VÀõ2‘ÀÞƒ<À»C À³jBABo¥BúB úBEÍBšdAÃM¿³\îÀì¦Àõ)>À÷×ÄÀ´ÄxA|(PB ³öB»¦B¸±ÕB¹ ¹B§ýA´1 Áí_Á"ï†ÁKÁñ-Á%³Í¿Î4ÍAž¬›AÀæÎrÁ&Û5Áä©Á*ȦÁ½ÁÀ¿ä„@ÎvA*mòA*°A2º°AµmÀ'‚EÁp5ÀÅVÖAµK®BF¦xB~spBidB}÷dB4@LA›ÚíAóÔ’BD{µBVÒB_VB“*XBˆ«(BEü°B,å×B'w>AóK%@¼:ãÀ¦4‡Á#JÁ3¿Á W Á&ß‘ÁzÁsLAwvA‰WAf|¡?°íÀœü?ÐÛ(@½_y@¯¯@®(Ï@ Ð?zr,À“@ À¼ÚØÀʱ ÀÀªðÀÁb(ÀâݼÀð"ÆÀê¨Àæ9LÁÔ†ÁŒóÁ4®Á0 Á/NDÁ*ð1ÁépÁ*!ëÀݵ5AâæBâÀB‰B ¬xB/=A¨ã×ÀC†µÀÅò5>¯ôAI}A=+AP2AqxçAo= ?Ü}ÐÀ…\)ÀƒÝÇÀ•ÄÓÀêgÀ «À¬AlÀ‚e¼Àž| À¤E[ÀWÀ¤ 6ÀºÔiÀ}ûAÙÕèB•ŽBŸ¤¤B˜ê#B›˜üÁŽÁ=‡Á$SÁ*ÝyÁKÒ;Á>LÁ&¸ÐÁêôÁ*¤…Á¤èÀ¿Œþ@ÎJÆA*.A*'ªA2ÃAAÁøÀ&í?Á7ÀÅC5Aµ3{BF§B~yâBpAB~B4GwA›ð%AóßáBDyŒBV“B_ŠB“*ÑBˆ³BF¦B,ðµB'†ìAó[Ç@¼ê¦À¥wÁ"ûãÁ3{ÈÁ 3-Á&±FÁ óÁL‚Awc,A‰#Af}’? êÀœÇ?Ñb@½@ç@ªž@®N@ ì@?|¡ÇÀ’ûÞÀ¼fÝÀÊA)ÀÀd1ÀÀ÷éÀâ0ÀïÀêqÀå¢ìÁLÄÁbÁ48¼Á/…ºÁ.å!Á*€µÁ—2Á)Ç=ÀÜùlAÿgBþíBšªB »¤BL‹A©òÀA¦kÀÅ9…>@ÚRAJlA=ÍwAPÒ)Ar%ÏAoš³?âpRÀ„ß"Àƒ«:À•8ÀÂÞÇÀŒÔmÀ«n>À‚ jÀ°)À£¬áÀ¦éÀ£J»ÀºiÐÀ}gÑAÙþZB•BBŸ±B˜ïB››œBvÊ+@ïÜ¿Àóä€Àï>ŒÀ¡X¿A}¬kAåY£AÜÙAØ9ßAÕ·ALš®À‚£“ÀºÊÎÀµç±ÀÛ¬ÀŸLÀ¡›)À¼ìEÀ¤‡ºÀƒ>»Aç¹B¯wBÜûBØçºB×íòB¸œ^A ÆžÀô®®ÀÝÓ À»4ÔÀ²aFABÜ’BÛB ŒB=ÙBœPAÃ}¿®2ÀëU¥Àõ9À÷+`À´²^A|s5B ž¾B»²åB¸­2B¹ÏB§"òA´ƒÔÁ˜Á"˜§ÁêbÁÃÁ%>ç¿Ë MAžÍ'AÁA¿ÊAÎX²A­ç*@›ÌÀûUýÁ™!Á6ëÁÁ ò¶¿ßä>@ª¾Æ@Ý~\A0O@ÙÛ*@.ãÅÀò¼èÁQœÀ²%A·ÉBedB*OkB7äùB?…ŽB þ€B­ÚC…QC2%Cª|CÇ B©çûA>ùÁ"îmÁÔvÁ%rÁGƒÁâQÀù;nÁ$TÁ¬FÁ#r÷Á*`LÁKF¦Á=ÈÕÁ&–8ÁñFÁ*€Á‹ñÀ¿4¦@Ά¶A*°¾A*KäA2ËçAÎÀ&WÁþ”ÀÅ/=Aµ BF§ÉB~€\Bw*B~.ìB4N©Aœ|AóëLBDwhBV¦nB_ÓB“+KBˆ»BF­B,û¨B'–¹Aóls@½›¬À¤¸-Á"­"Á37pÁ åÁ&‚®Á SÁ%sAwO²A‰ ÝAf~_?#%}Àœ‘ ?ÑWò@½"#@Â¥}@®s¥@¡¾?~ÔoÀ’·wÀ»òÀÉÐ\ÀÀãÀÀÀáEÀîÚ=ÀéwµÀå zÁÃ÷Á¬èÁ3ÂnÁ.þKÁ.{)Á*rÁDfÁ)kæÀÜ<AŽ#B ZB«ÛB ÊéBjA©\{À?ÂâÀÄ\>yiAKþA>‡WAQ‡‘ArÓÚAoøæ?èmVÀ„a'Àƒx$À”jaÀšÀŒ‡¹Àª™nÀ¬mÀœâÀ£/ÀŽõdÀ¢Š À¹þ¤À|ÓqAÚ'-B•BŸ½¥B˜ô!B›ŸBvÔ}@ðÑýÀó¹ŠÀî[òÀ ÔeA}±‚AåkÛAÜ-!AØQôAÕ+™.AL 2A?BÌAR>iAsƒ ApW¢?îtÜÀƒâ7ÀƒD…À“»LÀÁBàÀŒ:À©ÂûÀNÇÀœUÀ¢xFÀŽBˆÀ¡È,À¹’æÀ|=óAÚPcB•#ÞBŸÊBB˜ù9B›¢}BvÞÐ@ñÉÀóŽNÀíwÈÀ NÜA}¶¯Aå~7AÜ?~AØj+AÕEðALò#À¨…Àºm†Àµ\ÀlÀž¨À¡;%À»pÀ¢ígÀ‚¶MAçµ¹B¯”BÜúaBØûXB×óDB¸ BA¡`QÀô*hÀÝ÷À»&~À±TACKB»B #!B5®BžVAÂØr¿¨’Àê'ÀôöŠÀö|VÀ´ ñA|ÀcB ‰KB»¿ëB¸¨ˆB¹ÍB§'ÑA´ØÁB/Á"@UÁ¿ZÁ•8Á$È1¿ÈþAžî*AÁG¦A¿ØAΊ>A® m@!(:Àú@üÁqsÁ¦îÁdÁ ¨æ¿ßmÚ@«Ÿý@Ýë€APK@Ú\F@0{ÀòUËÁVêÀ°ÎA·ÒwBvIB*Q8B8¼B?§¿B þB¡”Cƒ„C;C¬‡CÇÅBªA…cÁ"šCÁ¯£Á$¿*ÁúÁ”ëÀù3íÁlÁ†ÅÁ"0¤Á)cÁJ,UÁ<¿Á&PuÁþÁ*6JÁY¤À¾‚@ÏsA*ôÚA*•A2ÝnAçåÀ%'6Á‹•ÀÅEA´éòBF©IB~gB…B~gB4]"Aœ0ŠAô|BDs+BVÍB_-¦B“,=BˆËLBF(êB-ÐB'¶¬Aóê@¿À£6“Á" ÚÁ2­ ÁÅTÁ&$’ÁÈÁÖƒAw(oA‰AfŒ?'£¦Àœ%ß?ÑÖ@¼ä@› @®¿T@¡B?¡wÀ’-òÀ»ÀÈëûÀ¿Œ À¿µ¤Àà 3Àí0ÀèBÅÀãÙbÁ¯AÁÉ>Á2ÒÁÁ-ì;Á-¤ºÁ)-™Á"Á(³AÀÚ¼—AŽVOB TñBΫB éºB¥ÏA©ÖÝÀ;òÀâ>µÙ­AM A?ÿÔARö²At3_Ap¶è?ô†ãÀƒbSÀƒ\À“ ùÀÀr˜À‹ìîÀ¨êçÀ€ðvÀ›ByÀ¡Ü&ÀŽUÀ¡À¹&•À{§WAÚyúB•-ÆBŸÖñB˜þbB›¥þBvé%@òÂÀóbÌÀì’ ÀŸÈ%A}»ñAå¸AÜQñAØ‚†AÕ`ÒAMFÀ)ëÀº>^Àµ[ÀQÀžqsÀ¡ qÀº¯öÀ¢DÀ‚qRAç´XB¯¥BÜùÇBÙ?B×õúB¸¢.A¡®Àóè ÀÜÅVÀ»GÀ°Ì³AC‚ÌB«B -zB1„BŸcAº¢¿¥ÓCÀê,xÀôérÀö#ÒÀ´˜|A|çÖB ~zB»ÆƒB¸¦0B¹ ÃB§*9AµªÁ Á"¡Á©ÊÁ}ÛÁ$Œ(¿Ç§²AžþØAÁ`zA¿üAΣ6A®=^@"rÀùµ#Á]aÁ^9Á÷VÁ ƒ’¿ß1a@¬¹@Þ"¢A`<@Úo@1H Àò!iÁYtÀ°&A·×"B~ÛB*R#B8.XB?¸ðB ÏB›jC‚¡C@hC­CÈ%BªFA*Á"o¸Á!Á$—.ÁáéÁmäÀù/úÁÁòƒÁ!­Á(âèÁIšÁ<9Á&-HÁ pÁ*íÁ@PÀ¾&¶@Ï>?A+fA*ºA2æPAô£À$ŒÁQ’ÀÄñDA´ÑBFªB~“øBŒ&B~ƒ`B4diAœF@Aô@BDqBVáRB_8/B“,¶BˆÓzBF4"B-B'ÆÒAóž´@¿¶MÀ¢sÎÁ!½SÁ2fûÁ  Á%õÁÞÁ®¢Aw§AˆúžAfì?)æUÀ›ï‡?Ò@¼Ä¨@•½@®å~@¡_Ã?‚¿aÀ‘èÖÀºŽëÀÈxiÀ¿C©À¿I ÀßmðÀìäøÀ禒Àã>¼Á#WÁV Á2YbÁ-ašÁ-8BÁ(»ÁH«Á(UóÀÙú~AŽs¾B rBàJB ùGBÄAª´À:ÐÀÂH>Ò·AN„A@¾qAS°lAtäÙAq¸?ú£kÀ‚á{À‚ÛªÀ’YjÀ¿ ÂÀ‹ž×À¨0À€‘{ÀšoûÀ¡>ÎÀŒØËÀ @ÒÀ¸¹±À{œAÚ£óB•7¾BŸã´B™›B›©‹Bvó{@ó¼ÇÀó7À몿ÀŸ@?A}ÁHAå£]AÜdyAØ›AÕ{ãAMJ¯À€ª›ÀºßÀ´ÎÀ"”Àž:˜À ÙFÀ¹îrÀ¡MÑÀ‚+ÕAç³#B¯·BÜù+BÙ8B×ø¸B¸¤A¡üqÀó¥ÀÀÜiûÀ» À°CóACºöB›B 7ÞB-LB wAœ¡¿£™ÀéÈ*ÀôÜ0ÀõʤÀ´2A}ÛB s›B»Í*B¸£ÕB¹³B§,›Aµ-¨ÁëÂÁ!æÁ”2ÁfXÁ$O«¿ÆMïAŸ¤AÁy~AÀ lAμQA®Z†@#¾,Àù(cÁI)Á Áì&Á ]õ¿Þô@¬„7@ÞZ&Ap&@Úß@2Àñì{Á[êÀ¯|ÂA·ÛÉB‡‚B*SB8GB?Ê1B ®B•=CÀCE>C®”CȇBª†AϽÁ"DßÁŠŽÁ$nøÁ¿¥ÁF¥Àù+åÁ±Á]BÁ éÁ(aÒÁI ÒÁ;²¡Á& êÁ ãÁ)ëAÁ&ÜÀ½Ë@Ï|«A+:EA*ßTA2ïEAmÀ#ò¹Á9ÀÄÛìA´¸"BFªûB~šB“;B~ŸÖB4k¶Aœ\Aô!BDnýBVõ6B_BÎB“-/BˆÛ¸BF?iB-(MB'×Aó¯‰@Àl\À¡¯¹Á!l5Á2 ZÁzmÁ%Å?ÁýÚÁ†|AwÅAˆõAf€(?,+jÀ›¸Þ?ÒU@¼¥@Â^@¯ ß@¡}I?ƒÞÓÀ‘£}ÀºîÀÈêÀ¾ú%À¾ÛÛÀÞº†Àì;žÀç 6Àâ£Á–bÁáôÁ1ÞýÁ,ÕèÁ,ÊõÁ(G§Áó¥Á'÷ýÀÙ6ÐAŽ‘iB ‡BòBëBâpAªRûÀ8LÀÁˆ>ïÇ{AO&¡AA~¡ATk—Au—wAqw@e:À‚_®À‚¦oÀ‘¦À¾Í`À‹PJÀ§5ÖÀ€1ÖÀ™›ÛÀ  ?ÀŒ!ëÀŸ{YÀ¸L;ÀzvÄAÚÎMB•AÇBŸðŠB™äB›­#BvýÓ@ô¹dÀó õÀêÁàÀž·*A}ƵAå¶&AÜwAس¤AÕ—"AMw]À€*”À¹ßÀ´†,ÀœóïÀžtÀ §¥À¹+À | ÀåÔAç²B¯ÌBÜøBÙ@B×û~B¸¥öA¢KiÀócGÀÜ æÀ»ÄÀ¯ºAACó€B‹B BKB)B¡‘AÂ~o¿ GÀéc<ÀôÎÄÀõpÍÀ´ˆA}8sB h­B»ÓàB¸¡yB¹žB§.÷AµYÁÀVÁ!¹"Á~’ÁN¯Á$º¿Äð¹AŸ ŽAÁ’³AÀDþAÎÕŽA®wã@% ·Àøš¼Á4ÊÁ ËbÁàÖÁ 8¿Þµå@¬÷u@Þ’ A€@Û ø@2äÉÀñ·Á^LÀ®ÒA·àlB=B*TB8`B?ÛƒB ™B C€âCJC¯œCÈëBª)ÙAvdÁ"¸ÁwëÁ$F†Á/Á/Àù'¯ÁSNÁÇÁ D"Á'ßÂÁH|ýÁ;*ËÁ%æ[Á _Á)ÅGÁ JÀ½n©@Ï»¶A+]xA+ÒA2øOADÀ#V½Á܈ÀÄÆ=A´žýBF«æB~¡/Bš\B~¼sB4s Aœr Aô&BDlíBW ;B_M‚B“-¨BˆäBFJÁB-3«B'çzAóÀh@Á#¯À êTÁ!Á1Ù(ÁTyÁ%•!Áú¾Á^AvìÊAˆïnAf€@?.ræÀ›æ?Ò•·@¼…[@Šï@¯2v@¡›?„ÿÌÀ‘]çÀ¹ž#ÀÇŽÀ¾°À¾nÀÞöÀë‘#Àæj³Àâ<ÁcÁlóÁ1c’Á,I&Á,\ÓÁ'Ó„ÁžÁ'™^ÀØqŽAޝPB ­0BöB¨BAª‘²À6 ŠÀÀÆ„?„ÐAP2aAB@fAU(2AvK9Aq×ô@~ÀÜìÀ‚p«Àò’À½øoÀ‹FÀ¦XÛÀ£À˜ÆÀ yÀ‹i³Àž´®À·Þ1ÀyÜÍAÚù B•KàBŸýsB™?B›°ÆBw-@õ·ÙÀòÞ¡Àé×qÀž,æA}Ì7AåÉA܉ËAØÌgAÕ²AM¤QÀS¬À¹®ÚÀ´=±ÀœÅ$ÀÌÀ uÀ¸gLÀŸ¨öÀŸQAç±=B¯áBÜ÷íBÙ#ZB×þLB¸§ÓA¢šýÀó ¶ÀÛ±À» vÀ¯/œAD,lB{B LÃB$³B¢³AÂ` ¿y»Àèý¯ÀôÁ-ÀõLÀ´€!A}aB ]°B»Ú¥B¸ŸB¹‚B§1NAµ„¶Á”ÆÁ!‹XÁhêÁ6ßÁ#ÕU¿ÃAŸ1–AÁ¬AÀiÓAÎîìA®•v@&]£Àø /Á DÁ @ÁÕdÁ ä¿Þvá@­ks@ÞÊPAß@ÛcW@3´qÀñ€ùÁ`šÀ®&A·å B™ B*TûB8yB?ìæB ‘Bˆ×C€COC°¥CÉQBª7AAÁ!îBÁe8Á$ÚÁz…Á÷Àù#WÁô„Á/¾ÁÁ'\·ÁGëÁ:¢ Á%™Á âÁ)žýÁó˜À½h@ÏûaA+€ÿA+*A3mA'À"¹˜Á¡Àİ5A´…±BF¬ÞB~§×B¡ˆB~Ù8B4zeAœˆ!Aô2;BDjàBWaB_XLB“.!BˆìaBFV)B-?B'÷úAóÑQ@ÁÜCÀ # Á È5Á1‘dÁ.0Á%d´Á÷‰Á5^AvصAˆé»Af€4?0¼ÈÀ›J?ÒÖC@¼eh@Â…p@¯YC@¡¹?†"LÀ‘À¹$‹ÀÇ'À¾euÀ½ÿ·ÀÝP?Àêå‡ÀåËÀáhbÁy[Á÷ Á0ç"Á+»SÁ+íÛÁ'^›ÁGïÁ':Àת¹AŽÍsB ËBB(}BöAªÐ×À4)‰ÀÀ‰?>÷AQ?ÄAC¿AUæ>Aw Ar9a@œÀY6À‚:^À=KÀ½!òÀбÌÀ¥z=À~áÀ—î·ÀŸ_{Àа&ÀìÐÀ·o•ÀyA¹AÛ$(B•V B  nB™©B›´tBwˆ@ö¸&Àò²ÀèëpÀ¡sA}ÑÎAåÜ$AÜœ”AØåMAÕÎ,AMÑ‹À~PÂÀ¹~TÀ³ôŸÀœ–3À”OÀ BþÀ·¡ªÀžÔÀXKAç°ŽB¯øBÜ÷KBÙ-„BØ#B¸©¬A¢ë+ÀòÞ ÀÛSÀ»"À®¤ADe¸BjB WDB RB£ÚAÂAu¿š§ˆÀè—‚Àô³kÀô»!À´xZA}‹ZB R¤B»áxB¸œ»B¸üaB§3 Aµ°ÆÁiÁ!]1ÁS:ÁêÁ#—|¿Â+öAŸB¼AÁůAÀŽìAÏmA®³>@'°ñÀ÷|»Á —Á 6¤ÁÉÑÁ ëo¿Þ7@­à3@ßöAŸ°@Û¦@4„ûÀñJfÁbÕÀ­xËA·é¨B¡òB*UôB8’NB?þXB –B‚C-CSûC±®CɹBªD»AƧÁ!Â}ÁRtÁ#ôòÁW¨ÁÏ›ÀùÝÁ•#Á—{ÁõÈÁ&زÁGX/Á:`Á%ž¦Á nÁ)xdÁÙÈÀ¼³V@Ð;ªA+¤ÚA+PŽA3  A(À"JÁf ÀÄ™ÕA´ltBDhØBW1©B_c*B“.šBˆôÌBFa¢B-J¨B(™AóâE@–ÀŸ[›Á uRÁ1IÁ‘Á%3úÁô;Á gAvĆAˆãöAf€?3 À›?Ó$@¼EC@Âã@¯€G@¡×h?‡FTÀÒÀ¸ª%ÀÆ ãÀ¾HÀ½ÃÀÜ™bÀê8ÉÀå*6ÀàÉwÁ éHÁ€8Á0i¬Á+,oÁ+~Á&èìÁñ>Á&Ú*ÀÖâOAŽëÑB éAB(6B8jB?A«lÀ2/IÀ¿??$2ARNÊACÈ«AV¥ºAw¶,Ar›W@ ¿MÀ€Ô‹À‚‡À†ÆÀ¼IçÀŠaÜÀ¤™þÀ~ÕÀ—²Àž½EÀ‰õAÀ#ÀÀ·fÀx¥†AÛO§B•`FB }B™%B›¸-Bwä@÷ºKÀò…%ÀçýÞÀÑA}×{AåïZAܯrAØþVAÕéöAMÿ À}LkÀ¹MvÀ³ªöÀœgÀ\NÀ øÀ¶Ú¨ÀþØÀÂAç° B°BÜö¦BÙ7¾BØB¸«A£;ôÀò›IÀÚõMÀºúÅÀ®|ADŸeBYB aÏBãB¥ AÂ"®¿—Ð}Àè0¶Àô¥Àô_MÀ´p¾A}µ©B G‰B»èZB¸šYB¸ø:B§5ìAµÝ2Á==Á!.­Á=‚ÁÎÁ#Y/¿ÀÄhAŸSÿAÁßuAÀ´IAÏ"A®Ñ=@)ŸÀöìaÁöÃÁ ëŽÁ¾Á IJ¿ÝöL@®U³@ß;ýA¯x@ÛéK@5VhÀñEÁdüÀ¬Ê(A·î@BªìB*VñB8«­B@ÛB §B|`C~WCXúC²¹CÊ$BªRJApCÁ!–kÁ? Á#ËÐÁ4™Á§}ÀùAÁ5*Áþ9ÁLÍÁ&S³ÁFÄ4Á9ËÁ%zÁ %Á)Q|Á¿ØÀ¼Tr@Ð|’A+ÉA+vÍA3æA5À!{ÓÁ*iÀăA´RžBF®ñB~µ;B°B8B4‰/Aœ´«AôJËBDfÓBWFB_nB“/BˆýFBFm+B-VGB(VAóóC@ÃQ4Àž’FÁ !ÙÁ1&ÁàÁ%òÁðÔÁã*Av°=AˆÞAf®?5WÀÀšÛ?ÓXZ@¼$ì@ÂzE@¯§‚@¡õ÷?ˆkãÀ‹¾À¸.òÀÆ(³À½ÎÀ½!8ÀÛá^ÀéŠëÀäˆ<Àà)zÁ X+ÁÁ/ë1Á*œ{Á+ lÁ&rwÁ™þÁ&y“ÀÖQA kB ©B:ŒBHnB^bA«PpÀ01ËÀ¾y+?2þ‚AS_sAD,AWf¨Axm\Arý×@ çÕÀ€NìÀÌ'ÀŽÏÀ»pNÀŠvÀ£¸À}Y:À–; ÀžÙÀ‰9ÀœY}À¶¤Àx5AÛ{‰B•j’B $ŸB™±B›»òBw'B@ø¾GÀòWþÀç»Àœ‡A}Ý=Aæ³AÜÂgAÙ‚AÖïAN,ÐÀ|F¥À¹AÀ³`µÀœ7ßÀ$ÀŸÜ{À¶GÀ'ÐÀ€È¶A篳B°+BÜöBÙB BØêB¸­NA£YÀòXnÀÚ–QÀºóaÀ­ŠADÙsBIB leBfB¦>A¶¿”ôšÀçÉJÀô—hÀôÎÀ´iNA}à‹B <^B»ïJB¸—õB¸ô B§83A¶ øÁCÁ ÿÌÁ'ÂÁîÁ#n¿¿YhAŸe`AÁùlAÀÙéAÏ;ÓA®ïp@*^¯Àö[ ÁáÉÁ ŸþÁ²GÁ ­¿Ý´»@®Ëô@ßueA¿8@Ü,á@6(¸ÀðÛ˜ÁgÀ¬0A·òÔB³úB*WñB8Å3B@!oB ÅBvC}‚C^C³ÄCÊBª_ìA ÚÁ!j Á,¼Á#¢tÁVÁ(Àù„ÁÔ™ÁcöÁ¢žÁ%ͺÁF/-Á9LÁ%V+Á +ŸÁ)*EÁ¥ÊÀ»ô¼@оA+íŠA+MA3@ABÀ Û3ÁîZÀÄlA´8ÙBF° B~»ùB·OB0sB4ŸAœË AôW>BDdÓBWZœB_y(B“/ŒB‰ÐBFxÄB-aûB(*2AôJ@Ä ÀÇ¢ÁÍÈÁ0¶¬Á¹TÁ$Ñ›ÁíUÁ¹§Av›ÛAˆØ5Af5?7¨ÖÀš¢â?Ó™ä@¼b@Ât˜@¯Îô@¢È?‰’ùÀE7À·²òÀů–À½‚EÀ¼±ÀÛ(4ÀèÛëÀãåÀ߈lÁ ÆÁÞÁ/k°Á* vÁ*›ôÁ%û;ÁB1Á&UÀÕL¿A)AB &PBMBX‹B}íA«ãÀ.1 À½±Ç?BæATq¾AEWAAX)Ay%±As`á@À±À”>ÀŽÀº•)À‰À™À¢Ô—À|“KÀ•^ÄÀu5Àˆ{tÀ›ŽÀ¶ OÀwiÆAÛ§ÌB•tïB 1ÓB™$MB›¿ÂBw1¡@ùÄÀò*‘ÀæÀ›øA}ãAæ1AÜÕpAÙ0ÒAÖ"ANZÛÀ{?rÀ¸ê´À³ÜÀœ}ÀœëqÀŸ¨ˆÀµH†ÀœOvÀ€€(A篈B°GBÜõXBÙLdBØ ÙB¸¯A£ßXÀòzÀÚ6›ÀºëöÀ¬û“AEâB8B wBÜB§{AÁ䌿’ßÀça?Àô‰&Àó¥¦À´b A~ ÿB 1%B»öIB¸•ŽB¸ïÙB§:tA¶7Áå&Á ÐŽÁûÁÖ%Á"Û9¿½êöAŸvàA”AÀÿÍAÏUºA¯ Ú@+¹ ÀõÈùÁ̧Á SõÁ¦PÁ v`¿ÝrR@¯Bõ@߯.AÎð@ÜpÞ@6ûêÀð£_ÁiÀ«håA·÷eB½B*XõB8ÞàB@3B ïBoÚC|°CcC´ÐCÊþBªm¡A ÆnÁ!=ZÁÇÁ#xÜÁíáÁV›Àù¦ÁspÁȳÁ÷;Á%FÆÁE™Á8uãÁ%1£Á 2CÁ)¿Á‹À»”5@Ñ@A,`A+Ä A3&¯AO4À 9jÁ±õÀÄT§A´ëBF±6B~¾B¾¨BMÖB4˜Aœá´AôcÏBDbÖBWoHB_„GB“0B‰hBF„nB-mÅB(;+Aô]@ÄË/Àœû®Áy Á0l Á‘µÁ$Ÿ÷Áé¼ÁßAv‡_AˆÒ:Af~˜?9üSÀšjY?ÓÛÄ@»ã¦@ÂnÜ@¯öœ@¢3Û?Š»—ÀþtÀ·6%ÀÅ5À½5oÀ¼@_ÀÚmãÀè+ÉÀã@ÐÀÞæLÁ 2ÓÁUÁ.ë)Á)yaÁ*)§Á%ƒ9ÁéÕÁ%¶oÀÔ™AHSB E6B_¨BhÀB²A«ÑÆÀ,-À¼èë?Q"_AU…­AF êAXìÔAyß*AsÄt@H¦À~¡À[ÌÀ[ÇÀ¹¸vÀ‰oFÀ¡ïqÀ{ÌÀ”€ÚÀœÏYÀ‡¼‹ÀšÁ_Àµ¯gÀvÊ9AÛÔqB•]B ?B™)úB›ÃBw<@úËÇÀñüÝÀå+ÀÀ›gÓA}éAæ)ÓAÜèAÙJDAÖ>lAN‰+Àz6ÒÀ¸¸ÏÀ²ÊlÀ›ØôÀœ²”ÀŸtÀ´}fÀ›uÌÀ€7A篊B°eBÜô®BÙVÐBØ ÑB¸°ÞA¤1óÀñÒmÀÙÖ,ÀºäƒÀ¬l3AEN±B'B ®BDB¨½AÁÅ1¿.LÀæø•ÀôzºÀóGÔÀ´ZïA~8B %ÝB»ýWB¸“&B¸ë B§<°A¶d—Á¸åÁ  óÁü+Á½—Á"›¿¼yAŸˆ}AÂ-ìAÁ%õAÏoÂA¯,y@-òÀõ5ìÁ·_Á rÁš8Á NÊ¿Ý/@¯º·@ßéWAÞ @ܵB@7ÏþÀðj™ÁjûÀª¶GA·ûòBÆVB*YüB8ø´B@DÈB &BiC{àCh2CµÜCËnBª{jA!rþÁ!\ÁÂÁ#O ÁÊ8Á-ÖÀù ¥Á¯Á,oÁJ¤Á$¾ØÁEúÁ7èÁ% éÁ 8ðÁ(ÚêÁqPÀ»2Ý@ÑCA,7ŠA+ëA302A\VÀ–xÁu8ÀÄ<çA´ÔBF²jB~É‹BÆ Bk`B4Ÿ’AœøhAôp~BD`ÞBW„B_{B“0~B‰BF(B-y£B(LBAô&y@ÅŠÀœ.jÁ#âÁ0"ÁiÁÁ$nÁæ ÁeÐAvrÉAˆÌ,Af}Ö?AFì'AY²Az™ÈAt(‘@€ïÀ}p¨À"ÑÀŒ MÀ¸Ú5À‰|À¡¨À{oÀ“¡NÀœ(GÀ†üKÀ™ó„Àµ=íÀv)AÜwB•‰ÜB LvB™/¸B›ÇƒBwFe@ûÕKÀñÎãÀä7éÀšÖvA}ïAæ=™AÜûÄAÙcÙAÖZðAN·ÂÀy,ÃÀ¸†“À²~eÀ›©EÀœynÀŸ?=À³°æÀššÑÀÛA篸B°„BÜôBÙaMBØÑB¸²ŸA¤…(ÀñHÀÙuÀºÝÀ«ÛáAE‰áBB ŒaB žBªAÁ¥¤¿ŒCàÀæJÀôl$ÀòéYÀ´TA~džB †B¼tB¸¼B¸çaB§>æA¶’oÁŒ€Á püÁæTÁ¤ãÁ"[t¿»¹AŸš7AÂHuAÁL`AωìA¯KM@.u%Àô¡øÁ¡ðÁ ºuÁÿÁ &í¿Üêò@°3:@à#âAîG@Üú @8¤õÀð1FÁlÔÀªUA¸{BÏ£B*[B9¯B@VŒB jBcCC{CmYC¶éCËáBª‰GA" ŠÁ ãÁ ó¬Á#$üÁ¦]ÁÚÀùƒÁ¯VÁ+ÁœÙÁ$5ïÁDiÍÁ7ZSÁ$çþÁ ?¤Á(²ÅÁVåÀºÐ³@цkA,]A,PA39ÉAi†Àò^Á8$ÀÄ$ÐA³ê–BF³«B~Ð_BÍ{B‰B4§A;Aô}IBD^éBW™B_šÅB“0÷B‰ÆBF›òB-…˜B(]wAô7 @ÆJ4À›_ÕÁÎ Á/ÖÒÁAwÁ$;ÅÁâAÁ;|Av^AˆÆ Af|ð?>ª€À™øW?Ô`@»¡–@Âc4@°F@¢rÇ?hÀp:À¶:"ÀÄ>·À¼šÀ»]+ÀØõÍÀæÈ#ÀáôÅÀÝžÚÁ SÁ ‹Á-ç Á(RÁ)BŽÁ$áÁ7qÁ$ð«ÀÒàA‡)B ƒÁB…VB‰rBÝèA¬TÙÀ(^À»RÉ?oªŽAW²rAG¸øAZxÄA{UŠAt8@¾zÀ|]ÆÀ€éLÀ‹ã•À·úgÀˆË=À  =Àz9‚À’À!À›ýÀ†:µÀ™$wÀ´ËàÀu‡ÄAÜ.àB•”kB YãB™5†B›ËtBwPÉ@üà¦Àñ ¤ÀãBÀšCêA}õAæQ„AÝAÙ}‘AÖw¢ANæžÀx!GÀ¸SÿÀ²1ÆÀ›yqÀœ?ÿÀŸ æÀ²ãÀ™¾…ÀFÙAç°B°¥BÜóTBÙkÚBØÚB¸´[A¤ØùÀñL ÀÙ ÀºÕ…À«JœAEÅrBB —BêB«WAÁ…濉TœÀæ%aÀô]bÀòŠ3À´M?A~‘ÉB  B¼ ŸB¸ŽPB¸ãB§AA¶À£Á_øÁ @¨ÁÐtÁŒÁ"㿹ŠîAŸ¬AÂc.AÁsAϤ8A¯jX@/ÖºÀô ÁŒZÁ lþÁ¤Á þǿܥü@°¬}@à^ÍAýæ@Ý?@@9zÎÀï÷gÁn˜À©MA¸BÙB*\B9,ÑB@hbB »B\òCzHCr‹C·÷CÌUBª—7A"ÏÁ µuÁ à†Á"ú´Á‚OÁÛ¦Àù?ÁLeÁðçÁíÚÁ#¬ ÁCДÁ6Ë+Á$ÂáÁ FaÁ(ŠRÁ<[Àºm·@ÑÊoA,‚ÙA,9ÒA3CtAvÂÀMÁú¸ÀÄ aA³Ð/BF´øB~×;BÔöB¦ëB4® A&.AôŠ2BD\ùBW®B_¦#B“1oB‰(ŒBF§ÌB-‘¡B(nËAôHÑ@Ç šÀšñÁwŸÁ/‹ÁØÁ$ 7ÁÞ^ÁãAvIPAˆ¿ÚAf{æ?A0À™¾Ý?Ô£_@»€B@Â]I@°nÛ@¢’¡?Ž>œÀ(ÂÀµºíÀÃÁéÀ¼KœÀºê¯ÀØ8ÀæžÀáMÀÜù†Á sÁ¤JÁ-crÁ'¼½Á(ÍÁÁ$ŒÁÝjÁ$ŒÍÀÒ®A¦îB £eB˜eB™ïBþXA¬— À& ¦Àº…ƒ?DAXËIAH‡]A[@äA|qAtòh@EÀ{HûÀ€¯>À‹%¡À· Àˆx‡ÀŸ60ÀynAÀ‘ÝRÀšÖ{À…wÈÀ˜T7À´Y@ÀtäÜAÜ\ªB•Ÿ B gdB™;eB›ÏqBw[.@ýíÙÀñrÀâKˆÀ™°/A}ûHAæe’AÝ"nAÙ—lAÖ”ƒAOÀÀw]À¸!À±äÀ›IvÀœFÀžÔÀ²ÈÀ˜àèÀ~±§Aç°šB°ÇBÜò£BÙvwBØëB¸¶A¥-dÀñ´ÀذƒÀºÍûÀª¸eAFcBóB ¡çB)B¬®AÁe÷¿†`Àåº×ÀôNwÀò*dÀ´F¨A~¿‡B ¬B¼ØB¸‹âB¸ÞÑB§CBA¶ï2Á3MÁ ÷ÁºÁsÁ!ÙÞ¿¸±AŸ¾AÂ~AÁšAϾ¦A¯‰—@1:°Àów\ÁvÁ Áu(Á ÖY¿Ü`,@±&@àšA }@Ý„Û@:QŠÀï¼ûÁpIÀ¨–wA¸ ‚Bâ{B*]'B9GB@zHB BVCy€CwÆC¹CÌËBª¥;A#~–Á ‡ŒÁ ÍPÁ"Ð2Á^ Á²:ÀøûÚÁèÜÁQ£Á=¨Á#!0ÁC6NÁ6;Á$’Á M&Á(aÁ!²Àº ê@ÒA,¨þA,a•A3M3A„ À¦­Á¼õÀÃóšA³µŸBF¶QB~ÞBÜ|BÄìB4¶2A=AAô—8BD[ BWÃCB_±˜B“1èB‰1aBF³·B-ÀB(€=AôZ @ÇÎBÀ™¾½Á ›Á/>½ÁïãÁ#Ö\ÁÚbÁæAv4mAˆ¹•Afz¸?CbFÀ™…?Ôæ‘@»^½@ÂWN@°—^@¢²½?mWÀŽáÀµ:ëÀÃD/À»üÀºwÀ×yÀå_øÀà¤ÀÜS!Á ÛªÁ' Á,ÞÕÁ'&eÁ(XÁ#›qÁ‚ÔÁ$(GÀÑ;8AÆïB ÃIB«˜Bª„BA¬ÙªÀ#ü¯À¹¶Æ?‡K‡AYåÃAIWVA\ vA|Ð}AuX"@ IQÀz2GÀ€t§ÀŠfnÀ¶6#Àˆ%[ÀžJ€Àx¡¬ÀøâÀš+ÂÀ„³„À—‚ÅÀ³æ Àt@×AÜŠÕB•©½B t÷B™AUB›ÓyBwe•@þüäÀñCRÀáRýÀ™FA~ŠAæyÅAÝ5äAÙ±jAÖ±“AOE(ÀvÀ·íÐÀ±–ÁÀ›VÀ›ÌDÀžÓÀ±C*À˜úÀ~oAç±NB°êBÜññBÙ%BØB¸·ÅA¥‚kÀðÅFÀØM-ÀºÆjÀª%B ‚BPDCx¹C} CºCÍDBª³SA$/Á YUÁ º Á"¥tÁ9™Áˆ—ÀøöSÁ„»Á±_ÁŒAÁ"•YÁBšüÁ5ªÁ$xÁ SôÁ(8~ÁêÀ¹¥L@ÒTSA,ÏwA,‰˜A3WA‘_ÀÿÁ~ÛÀÃÚ{A³šèBF··B~å Bä BãB4½ÊATtAô¤\BDY$BWØ•B_½!B“2aB‰:EBF¿²B-©õB(‘ÌAôkQ@È’-À˜ì:ÁÉÁ.ñ×ÁÆ™Á#£2ÁÖNÁºÞAvqAˆ³?Afye?EÁÄÀ™Jú?Õ*@»=@ÂQD@°À@¢Ó?™ÀŽ™À´ºÀÂňÀ»¬õÀºôÀÖ¹ Àäª1Àßú ÀÛ««Á CFÁ©Á,Y2Á&ŽýÁ'á§Á#Á'°Á#ÃÀÐf-Aç+B ãlB¾ïB»1B?æA­¹À!èzÀ¸æ?wA[ßAJ(äA\ÕxA}­Au¾e@#–ÀyªÀ€9‡À‰¥ÿÀµQ­À‡Ñ¸À]/ÀwÓÃÀÐÀ™ÒÀƒíêÀ–° À³rGÀs›³AܹcB•´B ‚žB™GUB›×ŒBwoýAãÀñ?ÀàXáÀ˜…-A~âAæŽAÝIoAÙË‹AÖÎÑAOtÕÀtö?À·º5À±H\ÀšéÀ›‘øÀžgÀ°q,À—!»À}„1Aç²-B±BÜñ=BÙ‹äBØ%B¸¹sA¥Ø Àð¾À×éÀº¾ÑÀ©‘!AFziBÐB ·”Bö}B¯pAÁ%ƒ¿€iÁÀäãæÀô0ÀñhÈÀ´9ýAºBŸì•B¼!xB¸‡B¸Ö*B§G‰A·MbÁÙ‹Á­ÁަÁ@”Á!Vy¿µ àAŸâMA´~AÁè°AÏóçA¯È¸@4 ¿ÀòI'ÁJ°Á ¿Á[ÌÁ „¥¿ÛÒ@²Ë@áÓA,’@ÞE@<©ÀïF~ÁspÀ§%LA¸zBõ¦B*_TB9| B@žEB øBIçCwöC‚\C»&C;BªÁ~A$à“Á *ÏÁ ¦²Á"z{ÁòÁ^»ÀøðªÁ ÁÁÙ§Á"‡ÁAþÁ58Á$R`Á ZÉÁ(ÁìÀ¹?Ü@Òš5A,öDA,±ÜA3`íAžÁÀVYÁ@iÀÃÁA³€BF¹(B~ëûBëªB€²B4ÅiAkÆAô±BDW?BWîB_ÈÀB“2ÙB‰C8BF˾B-¶?B(£zAô|¡@ÉW[À˜fÁpÎÁ.¤`ÁœùÁ#oºÁÒ ÁsAv ZAˆ¬ÖAfwï?H#§À™?Õmõ@»@ÂK*@°é@¢ó»?‘ÏbÀŽPñÀ´8~ÀÂEõÀ»\ÍÀ¹´ÀÕ÷ÒÀãóHÀßNÓÀÛ$Á©ÙÁ*Á+Ò‰Á%ö„Á'jZÁ"¢çÁËþÁ#]CÀÏA£B ÏBÒlBËöBaA­`7ÀÑÀ¸á?–óðA\ŸAJüA]¡ëA~PAv%3@&é*Àwÿ$Àû¼ÀˆäRÀ´k©À‡}ŸÀœn;Àw…À+À˜ÒªÀƒ&ùÀ•ÜHÀ²ýïÀrõqAÜèRB•¿QB WB™MeB›ÛªBwzgA@ÀðäçÀß]4À—íæA~OA梗AÝ]AÙåÏAÖì=AO¤ÈÀså À·†BÀ°ù_Àš¸£À›WcÀž/åÀ¯ÏÀ–@+À|ëîAç³:B±7BÜð†BÙ–³BØOB¸»A¦.IÀð>ÀׄSÀº·0À¨üAF·}B¿B ÂyBñ’B°ÛAÁÿ¿zÎ9Àäw~Àô ´ÀñüÀ´3èAL/BŸàóB¼(ÞB¸„ŒB¸ÑÎB§I¤A·}Á¬uÁ{¸Áx§Á'!Á!¿³…KAŸôAÂÏùAÂnAлA¯è™@5tØÀñ°³Á4~Á 2bÁNíÁ [_¿Û‰¦@²™@áNBA<@ÞX@<Û Àï lÁtæÀ¦j¸A¸ðBÿ[B*`pB9–ÞB@°\B "|BC†Cw4C‡·C¼7CÎ;BªÏ¼A%“ ÁûûÁ “KÁ"OHÁðÁ4¨ÀøêßÁº±ÁmÕÁ%ØÁ!z»ÁAa1Á4…hÁ$,|Á a§Á'ånÁÐýÀ¸Ùš@ÒàµA-eA,Ú`A3jéA¬0À¬qÁ Àç5A³eBFº¦B~òõBóRB€îB4ÍAƒ8Aô¾ûBDU_BXB_ÔuB“3RB‰L:BF×ÚB-žB(µFAôú@ÊËÀ—CBÁÁ.VVÁsÁ#;ôÁÍÚÁcÃAuõ*Aˆ¦[AfvT?J‡òÀ˜ÕÖ?Õ²&@ºøü@ÂE@±,@£?“³ÀŽˆÀ³¶ÀÁÅvÀ» À¹ÝÀÕ5sÀã;>ÀÞ¢tÀÚY‹ÁaÁª5Á+JÚÁ%\úÁ&ò8Á"%yÁo½Á"öÅÀη]A(WB $pBæ BÜÓB‚XA­¤%À¶SÀ·Aº?žÚôA]?AKкA^oÎA{AvŒ‰@*@øÀvâ´ÀƒWÀˆ!hÀ³„À‡)À›}¥Àv3óÀŽAÆÀ˜$KÀ‚^±À•>À²‰ÀrNAÝ£B•Ê5B ž$B™S†B›ßÔBw„ÓAŠÀðµHÀÞ_öÀ—UpA~ÒAæ·7AÝpÅAÚ5A× ×AOÕÀrÒkÀ·QøÀ°©ËÀšˆÀ›…Àø<À®ÉÀ•]JÀ|R¦Aç´sB±_BÜïÎBÙ¡“BØ"B¸¼ÁA¦… ÀïúfÀ×ÏÀº¯‡À¨fAFôñB­B ÍiBìšB²LAÀäJ¿t¿AÀä wÀôÀð¤†À´-ÿA|7BŸÕBB¼0RB¸‚B¸ÍkB§K¹A·¬ÿÁ;ÁI”Áb Á ˆÁ ÑD¿±ûDA  AÂë¥AÂ8oAÐ)°A°°@6âSÀñXÁ&Á âŠÁAìÁ 1пÛ@q@³@á‹AK‡@ÞŸN@=µRÀîÍÎÁvHÀ¥®ÒA¸cB $B*aB9±ÂB@ƒB % B=!CvuCC½ICιBªÞA&FÁÌØÁ ÓÁ"#ÚÁË Á ^ÀøäóÁTÈÁÊÁpÖÁ ëõÁ@¹Á3ñ®Á$fÁ hŒÁ'»oÁµØÀ¸r‡@Ó'ÔA-DÙA-%A3tøA¹«ÀaÁ€ÀÃA³IÏBF¼0B~ùöBûB€=B4Ô¼AšÉAôÌvBDS‚BXSB_à>B“3ÊB‰UKBFäB-ÏB(Ç0AôŸ^@Êå}À–lÏÁ¾¥Á.»ÁHºÁ#áÁÉ{Á7ÍAußàAˆŸÎAft•?Lî£À˜šÌ?Õö¬@ºÖ­@Â>Ç@±;‰@£5Â?”7‹À¿âÀ³2ÜÀÁD ÀººÕÀ¸¥pÀÔqíÀâ‚ÀÝôìÀÙ®áÁsßÁ)lÁ*Â&Á$Â`Á&yAÁ!§DÁíÁ"ŸÀÍÝ–AIFB EQBùÓBíÈB£èA­è‚À˜aÀ¶m?¦Î‚A^`AL§A_?#AÔAvôj@-žÀuÄ\À ßÀ‡]AÀ²šúÀ†Ô Àš‹lÀub ÀVÏÀ—tµÀ•À”1À²†Àq¥’AÝGVB•Õ)B ¬B™Y¸B›äBw@A¥¾Àð…dÀÝa&À–»ËA~jAæËúAÝ„‘AÚ¿A×' APÀq¾\À·VÀ°YŸÀšWXÀšá]ÀÀÀ­òöÀ”yÀ{¸XAçµØB±‰BÜïBÙ¬ƒBØ%¼B¸¾`A¦Ü“Àï¶•ÀÖ¸’Àº§×À§Ï!AG2ÇB›B ØbBç“B³ÅAÀÃc¿n¦˜ÀãœÐÀô]ÀðAfÀ´(BA¬ÑBŸÉƒB¼7ÕB¸žB¸ÉB§MÉA·ÝVÁQÞÁÁL‘ÁóÉÁ ü¿°mËA –AÂAÂ`³AÐDÇA°(ü@8R/Àð}Á§Á ’9Á4ÉÁ ù¿Úöc@³“à@áÈBAZô@Þæí@>zÀî£Áw–À¤ñ˜A¸ÑBB*b³B9ÌÎB@Ô»B '¨B6¸Cu¹C’ŠC¾\CÏ:BªìtA&úòÁgÁ lKÁ!ø1Á¥ÌÁ ßÛÀøÞåÀÿÜŽÁ&JÁº Á \5Á@#4Á3] Á#àÁ ozÁ'‘"Áš”À¸ ¢@Óo“A-l¡A-,+A3AÇ3ÀU'Áƒ ÀÃrA³.vBF½ÆBÿB‚ÃB€. B4ÜoA²{AôÚBDQªBX/*B_ìB“4CB‰^kBFðBB-ÛœB(Ù8Aô°Í@Ë®rÀ•• Ád®Á-¸ÁÁ"ÓÁÅÁ ‘AuÊ}Aˆ™/Afr±?OWºÀ˜_r?Ö;‡@º´+@Â8@±e@£W(?•mëÀwÀ²®×ÀÀÁ³ÀºiÀ¸/mÀÓ­@ÀáÇÇÀÝF=ÀÙ%Á×SÁ§»Á*8lÁ$&µÁ%ÿtÁ!(IÁµÁ"'ÑÀÍ;AjrB frB ½BþÕBŰA®-NÀw1Àµ—?®Î›A_‚¯AM~áA`èA€KíAw\Ô@1VÀt¤À~UÀ†—ÜÀ±°NÀ†~À™—’ÀtŽÒÀŒj6À–ÃçÀ€ÊÀ“Y’À±uÀpûöAÝwjB•à.B ¹öB™_úB›èHBw™®A1ßÀðU9ÀÜ`ÆÀ– ÷A~"AæàâAݘrAÚ5lA×E˜AP6CÀp¨àÀ¶è]À°ÛÀš&yÀš¥ìÀ‡†À­{À““–À{Aç·iB±µBÜîXBÙ·„BØ(þB¸¿ûA§4 Àïr«ÀÖQ›Àº  À§7=AGpýB‰B ãfBâ€BµDAÀ¢K¿h„?Àã.ŠÀóñrÀïÝœÀ´"¯AÝþBŸ½´B¼?fB¸}$B¸Ä•B§OÔA¸ Á$^Áä6Á6yÁÙãÁ J?¿®ÜÞA ,@AÃ#A‰;AÐ`A°I}@9ÄlÀïáïÀÿâÁ AmÁ'†Á ÝÛ¿Ú«|@´h@âÓAjZ@ß.ó@?l„ÀîRìÁxÑÀ¤3 A¸$B4ä)AÊLAôçÅBDOÕBXE"B_øB“4»B‰gšBFüB-ènÀº¦À·¸ÒÀÒçmÀá YÀÜ–fÀØVXÁ9½Á%"Á)­¬Á#‰ùÁ%„ÒÁ ¨ˆÁW¤Á!¿[ÀÌ%MA‹ÙB ‡ÒB!ÍBúBç²A®rŠÀRÂÀ´¿s?¶Û=A`¦úANXSA`âA€®aAwÅÈ@4gæÀsñÀ~¹À…Ñ:À°ÄÀ†(À˜¢ÀsºCÀ‹{ûÀ–âÀû¢À’€ðÀ±&ÑÀpQûÁ Ú¾ÁJ—Á9ÅÁ>áÁ21Á#’üÁ }nÁ';™Ác¯À·8d@ÔíA-½-A-~÷A3“ŸAâhÀù:ÁÀÃ<‹A²÷KBFÁB'B‚bB€M¢B4ëëAâÀ¹ÃºÀ·A¡ÀÒ tÀàOÊÀÛågÀרzÁ›Á¡¡Á)!çÁ"ì-Á% [Á (Áù)Á!V=ÀËFÊA­{B ©qB6B!7B íA®¸5À+À³æk?¾ôjAaÌèAO3YAaµÄAgAx/E@7Ô¶Àr]ÞÀ}— À… [À¯ÖOÀ…Ò4À—ªöÀrä`ÀŠŒÀ•^¥À~`]À‘§À°¯›Ào¥cAÝØ¸B•ökB ÖB™l±B›ðêBw®ALåÀïôÀÚ[PÀ”çÂA~/±Aç AÝÀuAÚk.AׂAP˜ÀnyÀ¶}cÀ¯eŽÀ™ÄKÀš..ÀôÀ«heÀ‘ÄžÀyãMAç»B²BÜìÙBÙÍ·BØ/œB¸Ã#A§æŒÀîêŽÀÕÀºšÀ¦AGî‹BeB ù‹BØ.B¸VAÀ_†¿\"|ÀâPÀóÑÀï À´A€!BŸ¥êB¼N¶B¸x*B¸»¦B§SÙA¸pÁÈòÁ}dÁ 3Á¥¦ÁÁj¿«°®A QìAÃ\;AÂÛAЖÙA°‹"@<° Àî¨ìÀÿ†ƒÁžjÁ ›Á ˆÅ¿Ú @µ»@â‚A‰ @ßÀ7@A'AÀíÕ×Á{ À¢±ôA¸-B1B*f1B:ÛBA ÆB /ÊB#eCs‘C£CÁ™CÐÈB«A)-Á =Á 1PÁ!sÖÁ4ÚÁ _ÀøËòÀýnjÁ 3wÁÅÁ§Á>>ZÁ1™ŸÁ#l Á „uÁ'^ÁHÀ¶Î @ÔJ‰A-åðA-¨¿A3žAðÀI…Á–ÀÃ!A²ÛzBFÂÓBFB‚BB€]@B4ó²AúMAõ‰BDL8BXqwB`;B“5¬B‰z&BGZB.»B)AôåU@ÎàÀ“áÁS?Á,ÇšÁœ:Á"4ˆÁ·Á…:Au‰·Aˆ„äAfl.?V¡hÀ—«ƒ?× @ºKv@Â%H@±ã@£¼é?™5ÀŒšòÀ±ùÀ¿5!À¹p@À¶ÉÚÀÑXTÀß’ÀÛ3@ÀÖù‹ÁûsÁ8Á(•Á"MPÁ$Á¦²Áš Á ìxÀÊf³AÏZB ËPBJYB2ŒB,aA®þOÀ(À³ ê?Ç!AbôxAPòAbŠÛAtÿAx™L@;FÈÀq7ãÀ}JÀ„@>À®æûÀ…{VÀ–²5Àr (À‰š¡À”ª1À|ÂiÀÌÀ°7ÑÀnølAÞ ñB–£B ä@B™s%B›õKBw¹AÛÉÀïÃÀÙV<À”IbA~6ŸAç rAÝÔ—AÚ†DA× •APÊ2Àm_×À¶GcÀ¯À™’ûÀ™ñáÀœÚúÀªŒËÀÛ(ÀyDéAç½)B²ABÜìBÙØêBØ2øB¸Ä°A¨@kÀî¦[ÀÕ[ÀºˆÌÀ¥iáAH-äBRB ­BÒñB¹êAÀ=Ù¿UãÀáßúÀóÀ±Àî®DÀ´þA€:yBŸ™îB¼VsB¸uªB¸·&B§UÓA¸¢EÁ›ÁIpÁôÁ‹NÁ|R¿ªjA dïAÃxÚAÃiAвxA°¬E@>)jÀî ÀÿXOÁL1ÁþôÁ ]Í¿ÙŬ@µ’…@âÀËA˜Y@à t@BòÀí–zÁ| À¡ïlA¸1gB;LB*gbB::‚BA@B 2™BìCrÞC¨«C¯CÑPB«&ÏA)ÖŽÁÜ“Á †Á!GBÁÏÁ 3¥ÀøÅ]Àüœ¨Á ‹1ÁÕ¿ÁlÁ=š£Á1RÁ#EÁ ‹ƒÁ&äÔÁ,OÀ¶bà@Ô”ÃA.A-ÒÇA3¨tAýÐÀ˜¨ÁÁÀÃ&A²¿BFÄšBmB‚"-B€lóB4ûAž}Aõ—BDJpBX‡ÔB`oB“6$B‰ƒƒBG!ØB.šB)"…Aôöì@ÎÞÞÀ’(ÞÁöìÁ,v%ÁpDÁ!þîÁ²+ÁWèAusíAˆ}üAfi¹?YÀ—nè?×RA@º(*@ÂÁ@² Œ@£ßY?šV²ÀŒQÀ°–¿À¾¯À¹9À¶Q{ÀÐ ÀÞÓIÀÚòÀÖIŠÁZ¿Á—çÁ(KÁ!­cÁ$ìÁ$žÁ:‰Á ‚ ÀÉ…AñtB ímB^×BCúBOA¯DØÀÑýÀ²/ñ?ÏLcAd¬APî AcabAÙ)AyÝ@>¾ÀpþÀ|švÀƒuäÀ­öÀ…$À•·ÑÀq4œÀˆ§À“ô†À{!ÉÀïÚÀ¯¿uÀnJWAÞ;ŒB– ìB ò~B™yªB›ù¸BwÃxAk™Àï‘ÏÀØO–À“©ÓA~=¡Aç5ëAÝèÎAÚ¡}A׿FAPü ÀlD¤À¶ À®¿ãÀ™a„À™µKÀœ ˆÀ©¯ÑÀðbÀx¥€Aç¿lB²sBÜëRBÙä-BØ6\B¸Æ8A¨šåÀîbÀÔ®}Àº€öÀ¤Î4AHmB@B ÙBͦB»„AÀû¿O™ùÀáo6Àó°ÀîGÓÀ´A€T4BŸäB¼^?B¸s(B¸² B§WÈA¸ÔeÁløÁÁÝÎÁpÐÁ6Æ¿¨v´A xAÕ©AÃ.AÐÎ9A°Í@?¥,ÀílOÀÿ)ÍÁùÁñ+Á 2Ž¿Ùw_@¶@âÿßA§ž@àS@Bå‡ÀíVÁ|÷À¡+‘A¸5ÃBE“B*h–B:VQBA0ÊB 5uBoCr.C®MCÃÅCÑÛB«5—A*ìÁ«šÁ ¬Á!sÁèÁ  Àø¾§ÀûÉ·Á áêÁ†Á~ÈÁ<õßÁ0hÁ#ÓÁ ’šÁ&¸ûÁpÀµöä@ÔßA.8sA-ýA3²üA —Àæ¢Á@•ÀÂèðA²£]BFÆmB$›B‚*$B€|¹B5WAž*ÌAõÃBDH¬BXžQB`(¹B“6œB‰ŒïBG.fB.B)5#Aõ@Ï® À‘J‹ÁšÁ,$ÁCùÁ!ÉÁ­7Á*OAu^AˆwAfg!?[‰1À—1þ?טÄ@º¬@Â+@²81@¤ ?›”¶ÀŒÀ°¸À¾("À¸Ç¤ÀµØ†ÀÏÄ ÀÞVÀÙË|ÀÕ˜wÁ¹Á­Á'xuÁ! eÁ#‘õÁ¡ÃÁÚcÁ ôÀÈ¡ÉA‘ÊB ËBsyBUBqöA¯‹ÑÀ ”À±R?׋.AeHƒAQÍâAd9[A‚=æAyn÷@B:¬Ànæ0À|À‚ªMÀ­«À„Ì6À”»ÌÀpZ¼À‡²ÀÀ“=£Ày~{ÀnÀ¯F†Àm›$AÞm‰B–EB¡ÐB™€?B›þ0BwÍîAüUÀï`EÀ×G_À“ A~D¹AçK‡AÝýAÚ¼ØA×Þ&AQ..Àk(ÀµÚ[À®l+À™/èÀ™xkÀœe À¨ÑxÀKÀxAçÁÜB²§BÜêŒBÙï€BØ9ÈB¸Ç¼A¨õùÀîªÀÔCåÀºyÀ¤1”AH­·B-B BÈNB½$A¿ùë¿IG.ÀàýÒÀóŸ[Àíà¹À´ aA€n9BŸÊB¼fB¸p¤B¸®B§Y·A¹àÁ>ÆÁàrÁÇÁV,ÁðÆ¿¦Ô‹A ‹NAò©AÃWÚAÐêA°ï+@A#OÀì̧ÀþúýÁ¦SÁãBÁ ¿Ù(9@¶–[@ã?TA¶Ú@à#@CÅþÀíÁ}ÏÀ fbA¸:BOîB*iÎB:rFBACeB 8]BîCq€C³ùCÄÜCÒhB«DrA+JEÁzRÁ õÂÁ íiÁÂÁ Ü;Àø·ÏÀúõ–Á 7¢Á\Áé*ÁpBZ^B*k B:ŽbBAVB ;RB iCpÔC¹¯CÅôCÒ÷B«SaA,›ÁH¼Á áÇÁ À%Á›{Á °3Àø°ÖÀú DÁ Œ[ÁvÁR‘Á;©1Á/2ïÁ"οÁ  àÁ&`\ÁØVÀµw@Õw.A.ŒDA.RbA3ÈIA'KÀÁ½7À¯|A²jŸBFÊ8B3B‚:3B€œ€B5Až[ËAõÑÀÆÖA‘Y)B UCB+BxÑB¸oA°À 4À¯“3?è.dAg£AS’"AeížAƒ AzFÉ@IC”ÀlŒÙÀ{ÀfÀ«%À„<À’¾ÚÀn¢ÿÀ…ÄXÀ‘Ì8Àv/×ÀSýÀ®RðÀl9dAÞÒ¨B–/*B¡«B™›BœABwâßA ‘Àîü_ÀÕ2>À‘Ä A~S*Açw-AÞ%öAÚóøAØqAQ“AÀhêwÀµkõÀ­ÂóÀ˜Ì>À˜ýÏÀ›îkÀ§§À(*ÀvÁ#AçÇ@B³BÜèùBÚYBØ@¹B¸Ê´A©­ôÀí”—ÀÓlˆÀºiFÀ¢õ~AI/ BB 1˜B½sBÀzA¿µ7¿<„‰Àà+Àó}[Àí‡À´rA€£BŸijB¼uüB¸k–B¸¤ëB§]†A¹léÁá÷ÁvÁšúÁ qÁci¿£…áA ²%AÃí:AìZAÑ"GA±2è@D&¹À늣ÀþœtÁþÁÇ Á¯¿Ø‡`@·5@ã¿aAÕ;@á2q@E‰“À쓇ÁEÀžØ A¸BÁBdâB*lHB:ª¦BAhËB >TBàCp*C¿pCÇ CÓ‡B«bdA,ÁíÁØÁ ͼÁ ’¦Át£Á ƒóÀø©ºÀùIÃÁàÁÝ ÁºþÁ;HÁ.–ùÁ"¦êÁ ¨Á&3•Á¼À´®@ÕÃæA.¶«A.}lA3ÓA57ÀÉ™Á{ÀÂ’?A²NBFÌ1B:SB‚BLB€¬B5AžtyAõJõBDCvBXâ’B`NB“8B‰©ŒBGTrB.BîB)m³Aõ=¯@Ò#sÀާ²Á¹Á+*Á½Á!%~ÁÆÁŸãAuÁAˆa§Af^~?böáÀ–y]?ØnI@¹™@ @²¹f@¤k¬?ŸWïÀ‹'yÀ®qÓÀ¼¸À·Æ“À´j ÀÍ^pÀÛÌ·À×§,ÀÓ~ÙÁ͈Á y’Á%ÅÐÁ#Á"ÁÁ¶œÁÑÃÀÅî”A‘|3B x_B²À­msÀ˜š0À˜ÀÀ›²À¦./ÀŒ8 Àv£AçÊ5B³KBÜè,BÚÞBØD>B¸Ì*Aª ÙÀíOéÀÒÿÃÀºaRÀ¢VAIpIBÿõB <ëB·ñBÂ.A¿’“¿6®ÀߥéÀólÀì§oÀ³üA±U@E«ÿÀêèGÀþl»Á©ôÁ¸½Á‚¿¿Ø5­@¸!Â@ãÿùAä^@á}²@Fl±ÀìQkÁâÀžàA¸GBo|B*mŠB:ÇBA{—B AcBœüSCoƒCÅ;CÈ'CÔB«qzA-;Áä¥Á ¹¡Á dìÁM™Á W{Àø¢}ÀørÁ2ËÁ—Á"qÁ:XQÁ-úÁ"~äÁ ¯GÁ&€ÁŸÀÀ´>Ä@ÖA¹Ô^Á„šÁ ÁnDÁêÁÔ=¿ )mA ÙsAÄ(ŽAÄèAÑZûA±w{@G3§ÀêEÀþ<µÁTáÁªNÁV¿×ã!@¸§@ä@ñAóz@áÉ[@GP±ÀìÃÁ€kÀDcA¸KWBz*B*nÐB:ã¡BAŽsB D~BœõÂCnßCËCÉACÔ¯B«€£A.=…Á²$Á ¥uÁ 6÷Á&\Á *ËÀø›À÷™1Á„ƒÁZYÁˆêÁ9®OÁ-\PÁ"V¬Á ¶†Á%ÙÁƒFÀ³Î°@Ö_1A/ sA.ÔBA3èÓAQ7À[Áõ›ÀÂV»A²TBFÐEBHóB‚RŸB€Ì¿B5*éAž¦6AõhSBD@BY¸B`gkB“8õB‰¼ìBGn!B.]™B)“ÿAõaN@ÓÍKÀŒß=ÁÀ–Á*nÁa€Á ¶óÁ’þÁB?AtïAˆSAfX?gö­À•ü¶?ØþI@¹PA@ÁöR@³š@¤³b?¡á¹ÀŠ‘;À­ZÀ»w~À·nÀ³rêÀË¿:ÀÚB¦ÀÖ3ÚÀÒÁ€±Á døÁ$žðÁ×vÁ!¡ÁßÁñOÁõ°ÀÄâA‘ÂøB ¿SBÜÊB®B#ÔA°õ2Àx×À¬é:@À¡Ak7>AVDXAh†ÏA„>'A{ŽŒ@SøTÀhøƒÀyŠÿÀ};À¨08ÀƒOÀ·.ÀljÀ‚ÒÀ˜÷Àq%ËÀŠ­YÀ¬áAÀjbAßm4B–RB¡I„B™¢"Bœ/BxSAÝÕÀîdxÀÒËÀÓŸA~irAç¹¶AÞcßAÛG®AØ{=AR,çÀeƒmÀ´ÃÊÀ¬À¯À˜5¢À˜C¿À›8"À¤e"ÀŠTÀtÓ”AçФB³ÀBÜæBÚ)BØKaB¸ÏAªÆvÀìÆBÀÒ$ ÀºQRÀ¡CAIóäBÿÎB S±B¬ÄBŬA¿L·¿)èÀÞ½†ÀóIÀëÓBÀ³ôRA€ô™BŸDjB¼ŽeBY'þB`t5B“9mB‰Æ²BG{B.kB)§RAõs-@Ô¤À‹ù Á`"Á*+ûÁ34Á 8ÁuÁAtØ’AˆK©AfT•?jz,À•½ë?ÙFÉ@¹+”@Áï^@³<†@¤×¡?£(éÀŠEÂÀ¬Í¶ÀºêþÀ¶À‡À²ömÀÊíåÀÙ{ìÀÕxvÀÑ[žÀÿ±kÁ ÙOÁ$ øÁ0Á ŒªÁ€_ÁÒÁ†«ÀÃ-*A‘æµB ã-BòIBÀ—BHA±>ÇÀ3õÀ¬ö@¥AlkæAW-’AiglA„¦QA{üà@W”kÀgÃ?Ày«À{•rÀ§4yÀ‚³¾Àޱ[Àk#ÀÓôÀŽÚÈÀormÀ‰È½À¬dáÀihzAß¡{B–]¾B¡XGB™©BœêBx ÒAtÀî1IÀÐõ,À+ÈA~q AçÐ+AÞx­AÛcÜAØ›3AR`ªÀd^:À´‹ À¬iiÀ˜"À˜'ÀšúrÀ£~ŒÀ‰`Àt-AçÔB³ýBÜå»BÚ4ÐBØNÿB¸ÐmA«%,ÀìJÀѵÀºIGÀ qõAJ6CBÿ»B _#B§BÇuA¿)¿"ŠüÀÞHeÀó7\Àëh-À³ðžAUBŸ7÷B¼–oB¸abB¸’QB§dáAº=AÁ&¯ÁœÄÁAoÁ³1ÁCA¿œ¿/A¡9AÄd¤AÄX„AÑ”5A±¼å@JJÀèûÎÀýÛ¿Á©MÁ Áûî¿×;}@¹³ï@äÄA˜@âaä@IZÀë‡ÌÁCÀ›«oA¸SßBÅB*qeB;9BA´^B JÚBœè•CmCÖØCËxCÕßB«Ÿ1A/½ ÁL7Á |ìÁÚ\Á×IÁ ÐÅÀø‹ýÀõãßÁ$ñÁ ÒBÁRìÁ8W#Á,þÁ"¨Á ÅÁ%}fÁIöÀ²ì@ÖüùA/cŠA/,A3þéAmiÀçûÁnÓÀÂØA±ÚBFÔ‹BW±B‚cB€íKB5:ìAžØqAõ†'BD<½BY?dB`B“9äB‰Ð‡BGˆB.x™B)ºÃAõ…@Õ|.À‹‡ÁÿÁ)ÕöÁ“Á G0Á‡ÓÁãƒAtÁúAˆD/AfPÿ?mÀ•~Ï?Ù@¹µ@Áè[@³h©@¤ü"?¤q À‰ú À¬@Àº]“À¶hÀ²yZÀÊjÀØ´ÀÔ»êÀУÀþ_aÁ L¾Á#súÁ‡¢Á ÝÁøÁ)ÈÁýÀÂ>ßA’ ­B EBìBÒÄBlŠA±ˆË¿ýרÀ«9@ PïAm¢0AX`AjIyA… A|k¾@[5ÃÀfŒÀx}EÀyìéÀ¦7,À‚X·À©æÀj@aÀ€ÓÆÀŽbÀm¼`ÀˆâïÀ«çïÀh±tAßÖ$B–iB¡gB™°$Bœ±BxSA GÀíýÔÀÏáýÀŽ‚ÂA~x¸AçæÅAÞ‘AÛ€,AØ»WAR”³Àc7˜À´Q÷À¬ŒÀ—Ð|À—ÆEÀš¼JÀ¢––ÀˆjÎÀs…oAç×ÅB´;BÜäæBÚ@˜BØR¥B¸ÑÏA«„~Àì<9ÀÑEmÀºA4ÀŸÎµAJyBÿ§B jžB¡`BÉDA¿¿ô`ÀÝÒ¤Àó%rÀêünÀ³íA,ZBŸ+uB¼ž°B¸^ÐB¸œB§fªAºr;Á÷…ÁeÁ*ùÁ—‚Áú¿›äA¡HAÄ‚÷AÄ„8AѱA±ßë@KØæÀèUØÀýªÏÁRÌÁ~:ÁÎm¿Öæe@º;€@å A ›@â®Ã@JÀëC}Á’ÀšÜ÷A¸XBš±B*r¶B;:?BAÇkB NBœáøClÿCÜÌCÌ•CÖzB«®•A0~LÁËÁ hÁ«·Á¯sÁ £oÀø„9ÀõnÁs¨Á iÁ¶vÁ7©ûÁ+}uÁ!ÜÛÁ ÌvÁ%OÁ- À²y‹@×LÌA/”A/XhA4 A{•À,®Á*ìÀÁúãA±¼BFÖÀB_B‚kpB€ý¯B5BøAžñ¾Aõ•=BD;BYVìB`Ž B“:\B‰ÚlBG•#B.†9B)ÎRAõ— @ÖUƒÀŠ(µÁtÁ)`ÁÕœÁ ÙÁ‚Á³½At«HAˆ<¤AfME?oˆ_À•?d?ÙØÆ@¸á¤@ÁáH@³•@¥ ä?¥»ßÀ‰®À«± À¹Ï:À¶À±û°ÀÉGÈÀ×ëÀÓþ6ÀÏéuÀý CÁ ¿EÁ"ÜöÁÞÁ„;Áo ÁÅ/Á¦¨ÀÁOA’.áB +B´Bå B‘¿ù@éÀª2@ ¢}AnÚAYÂAk,÷A…x\A|Û%@^Ü[ÀeRýÀwôÌÀxAæÀ¥8RÀý9ÀŒ ÏÀi[ÞÀ£ïÀZÄÀl§À‡ûîÀ«jiÀgùPAà .B–umB¡vB™·=Bœ#‚Bx!ÕA £cÀíÊÀÎÍ<ÀØA~€{AçýƒAÞ¢ŠAÛœŸAØÛªARÉÀb‰À´‹À«¹À—±À—‡Àš}¬À¡­AÀ‡t0ÀrÜÔAçÛ˜B´{BÜäBÚLoBØVSB¸Ó-A«äkÀë÷ÀÐÕÀº9ÀŸ*ƒAJ¼"Bÿ”B v$B›™BËA¾âz¿TÀÝ\DÀó^ÀêÀ³é¹AH¨BŸäB¼§B¸\A/»ñA/„öA4PA‰ÎÀp7Áæ®ÀÁÛ•A±ŸBFÙBfB‚sÌB'B5K AŸ +Aõ¤pBD9xBYn•B`›B“:ÔB‰ä_BG¢DB.“îB)âAõ©@×0À‰>“Á;;Á)(7Á¦PÁÖ5Á|EÁƒ±At”|Aˆ5AfIf?rÀ”ÿ¨?Ú"D@¸¼`@ÁÚ&@³Á’@¥Eé?§¥À‰aíÀ«"bÀ¹?öÀµµ€À±}oÀÈrÿÀ× öÀÓ?[ÀÏ.ÇÀûµÁ 0äÁ"DíÁ3‹ÁþÄÁå7Á`Á5ªÀÀ]ŒA’SPB P5B3 B÷gB¶&A² ¿ô£­À©GX@úQAp®AYò¹AlæA…â=A}K@bˆ4ÀdþÀwk@Àv”gÀ¤7ëÀ¡EÀ‹–ÀhvÀ}ÀŒ˜ïÀjH@À‡ºÀªìQÀg@Aà@›B–^B¡…B™¾hBœ(_Bx,YA —À ÂŒÀ†|@Àr34AçߘB´½BÜã7BÚXXBØZ B¸Ô†A¬DóÀë±ÎÀÐcèÀº0øÀž…_AJÿ£Bÿ€B ´B•ÅBÌøA¾¾­¿ªÀÜåEÀóÀê"óÀ³æ‡Ae?BŸDB¼¯_B¸Y¦B¸„ B§j,AºÝBÁ˜ÅÁö ÁýõÁ_°Áfa¿—…öA¡=ÁAÄÀ1AÄÜjAÑë A²&–@Ný¡Àç:ÀýHÁ¤^Á`1Ár“¿Ö9©@»Lâ@å‹xA>ˆ@ãI¸@KÑùÀê¹;ÁóÀ™<A¸`ŽB°ÉB*u`B;tÁBAí¸B TÄBœÔ²CkËCèÒCÎÑC×¶B«Í™A2½Á±Á ?¤ÁM¼Á_.Á HÀøtMÀóJüÁÁ }Áz›Á6L„Á*9¦Á!ЬÁ Û>Á$ñ„ÁóÀ±’@×îOA/è¢A/±ÄA4 ¢A˜À²—Á¢ÀÁ»ðA±ZBFÛOBnB‚|3B²B5S%AŸ$·Aõ³ÁBD7ÛBY†`B`¨2B“;LB‰îbBG¯uB.¡¹B)õËAõ»@Ø õÀˆS!ÁØjÁ(Ð}Áv¯ÁBÁvYÁS_At}–Aˆ-WAfEc?t ,À”¿œ?Úl@¸–é@ÁÒô@³îX@¥k1?¨TòÀ‰ƒÀª’VÀ¸¯ÅÀµ[cÀ°þ˜ÀÇÀÖU·ÀÒWÀÎsÀú\ÊÁ¡›Á!«ÞÁ‡çÁxxÁZÁúRÁÄÀ¿j…A’wüB u BI±B ÝBÛJA²ir¿ïÿóÀ¨[3@XjAqNáAZâCAløEA†L±A}»‘@f9NÀbÛÀvà£ÀtänÀ£5öÀDÛÀЉ¹ÀgŽÜÀ{’éÀ‹ÕãÀhŠ+À†*TÀªm¦Àf…®AàviB–_B¡”B™Å£Bœ-GBx6ÞA Ö]ÀíaÑÀÌŸÀŒ€—A~BAè+lAÞ̾AÛÕïAÙÜAS2pÀ_» À³¤ªÀ«hÀ—7§À—éÀ™ÿ ÀŸÖxÀ…ƒÀqˆŽAçãÄBµBÜâ]BÚdQBØ]ÉB¸ÕÚA¬¦ÀëltÀÏòÀº(ÎÀßHAKC„BÿlB NBâBÎÛA¾š¯¿öjÀÜm¦Àòî´Àéµ7À³ãA‚ BŸ•B¼·ÌB¸WB¸YB§kåA»NÁi/Á½»ÁçfÁCÁÙ¿•ÁTA¡R*AÄßAÅéAÒBA²J=@P“Àæ^‘Àý/ÁLpÁPúÁD:¿Õâ@»Öµ@åζAMr@ã—Í@L»IÀêsFÁ‚À˜iœA¸dÁB»ôB*v»B;’dAõÃ/BD6CBYžKB`µgB“;ÄB‰øtBG¼·B.¯™B* ´AõÍ @ØéÀ‡f^ÁuÁ(x1ÁF¸ÁdÁpSÁ"ÈAtf—Aˆ%•AfA@¸q@@Á˳@´V@¥º?©£ÇÀˆÈÝÀª|À¸¨Àµ¸À°*ÀÆÅúÀÕ‰WÀѾ,ÀͶ6ÀùoÁjÁ!ÉÁÛ2ÁñVÁÏ=Á”ÁQ¸À¾uéA’œãB š"B_çBjB§A²µ3¿ëU½À§m•@¼ÈAr‹·A[ÓbAmàA†·¶A~,–@iï¨ÀaœEÀvTóÀs1ûÀ¢2tÀ€çúÀ‰{»Àf¦\Ày…À‹ŸÀfÉiÀ…?»À©îhÀeÊ/AଙB–™rB¡£5B™ÌîBœ2:BxAeA q;Àí-CÀË…“À‹ÒÕA~˜EAèB—AÞáøAÛòËAÙ=ºASgÀ^ŽÈÀ³j6Àª¬-À—iÀ–ÇâÀ™¿ ÀžéÀ„ˆnÀpÜãAçèBµEBÜá€BÚpZBØaB¸×)A­ÓÀë'ÀÏ{Àº À8@AK‡ÇBÿYB ˜òB‰òBÐÆA¾v¿9 ÀÛõgÀòÜ ÀéFÑÀ³à§AŸJBžøÖB¼ÀHB¸TtB¸zŒB§m˜A»IµÁ9vÁ…ÁÐÐÁ'GÁÐÞ¿“ù>A¡f±AÄþ,AÅ5«AÒ%šA²n@R+àÀåµÀüäÁôÁA£Á™¿Õ‰‡@¼aH@æTA\T@ãæJ@M¥{Àê,ÆÁ‚À—•×A¸hðBÇ4B*xB;¯ÞBBGB [ŸBœÇ]Cj¡CõCÑCØúB«ìëA3ÁH Á wÁîÖÁÁ ëçÀøcÚÀñ‰ËÁ¤Á èýÁ:ÖÁ4êÚÁ(ò/Á!7·Á ê'Á$’·Á¸‘À°§:@Ø’NA0BÿA0 "A47A´ÃÀ3ÜÁèÀÁ{žA±EvBFàB}B‚$B@B5clAŸX0AõÒºBD4¯BY¶XB`±B“<;BŠ•BGÊ B.½B*¼Aõß<@ÙÇqÀ†xLÁÁ(RÁkÁ*tÁj5ÁñëAtO~AˆÁAf<ñ?yÁ“À”>”?Ûº@¸Ke@ÁÄb@´H‰@¥¶†?ªô#Àˆ{úÀ©oÖÀ·ŒŸÀ´¥À¯ÿ%ÀÅí¾ÀÔ»ÖÀÐûÚÀÌøSÀ÷¦Á€QÁ v®Á-mÁi_ÁCÁ-;ÁÞÂÀ½¹A’ÂB ¿wBvBB/B&=A³c¿æ¥À¦~@'kAsÊ0A\ÆAnÉVA‡#NA~ž$@m«CÀ`[ŒÀuÈ0Àq} À¡-eÀ€Š¤ÀˆlÀe¼ˆÀwtÖÀŠL$ÀeúÀ„SðÀ©n—Àe “Aàã*B–¥•B¡²jB™ÔKBœ78BxKíA ÀìøoÀÊjÀ‹#åA~ ]AèYæAÞ÷GAÜÊAÙ^ÇASœõÀ]aÀ³/kÀªQZÀ–ÑÀ–‡‘À™~‘Àú2ÀƒŒŒÀp02Açì¡Bµ‹BÜà¢BÚ|tBØe`B¸ØtA­j,ÀêáuÀÏ /ÀºdÀœDAKÌjBÿDB ¤ŸBƒõBÒ·A¾R¾ôäÀÛ|‰ÀòÉaÀè×ÁÀ³ÝøA¼½Bžì B¼ÈÓB¸QÙB¸u¹B§oFA»€xÁ šÁL Áº2Á ÙÁ…n¿’-·A¡{UAÅrAÅb±AÒCA²’*@SÆ’Àå ŒÀü±”Á›'Á2*Á毿Õ00@¼ì›@æVSAk.@ä5.@NÀéå¸ÁòÀ–À¾A¸mBÒˆB*yzB;ͧBB'§B _ BœÀ¬CjCû'CÒ0CÙ B«ü±A4SIÁÁ ÈÁ¿ ÁåIÁ ½zÀø[nÀð§jÁî6Á  Á™|Á48sÁ(MÁ! ñÁ ñ¨Á$bÚÁ› À°0š@ØåÀcÿAáQrB–¾B¡ÑB™ã5BœAWBxaA G_ÀìõÀÈ/ÎÀ‰ÂwA~°ÏAèˆðAß"'AÜJ1AÙ¡lAT‘À[+À²¸ÍÀ©™ïÀ–iÌÀ–À˜ü;ÀœmÀÕÀnÓÀAçö0B¶BÜÞÞBÚ”ÙBØmB¸ÚûA®0®ÀêVÀÎ#hÀºÜÀ›=wALVÒBÿB ¼BwÐBÖ­A¾Ⱦ٪ÀÚˆîÀò£cÀç÷¥À³ÙAøBžÒCB¼ÚB¸L›B¸lB§r‘A»ïÁ ©wÁØæÁŒÞÁÑŠÁí2¿ŽŒPA¡¤øAÅ\‘AއAÒ~mA²Úï@WÀã²íÀüKÄÁç÷ÁÔÁˆ¿Ôzö@¾…@æßtAˆÈ@äÔ,@Pi_ÀéUøÁÀ•’A¸ufBépB*|GB< ®BBN˜B fGBœ³?ChôC “CÔsCÚðB¬xA5â”Á¨BÁ Ø9Á^ÄÁ“Á _øÀøJ1ÀîßÁ~¡ÁÊÁSÚÁ2Ð~Á'Á ¹ÒÁ!ÃÁ$3Á_áÀ¯@å@ÙŒöA0ÍA0•”A4ZgAà*À íÁFÀÁA°êqBFçŠB“ÖB‚¦áBr”B5| AŸ¦QAö BD0 BYÿGB`ëB“=¢BŠ!RBGòaB.çðB*Z‡AöÎ@ÜjÀƒ¦7ÁáÁ'LÁƒ†Á{õÁWFÁ]±At ˜AˆØAf/6?€Â×À“z¯?Ûâ,@·Ø¥@Á®@´Ñl@¦)u?®îcÀ‡“çÀ§¶ÀµÐøÀ³ƒÀ®{ÀÃ^!ÀÒLŠÀέóÀʸDÀó„:ÁÇ•ÁŸ=Á¹ÁÌzÁ™ýÁõmÁóÀº“²A“2ÕB0ôBº.Bg‘B˜XA³è¿ØkûÀ£¨j@,ŒóAwkA_§¤Aq¼Aˆi„Aö@xý˜À\èÀtzÀlObÀžæÀ~ß³À…3lÀb÷Àq/?À‡ôfÀ_«›À‰^À§ë´ÀbÑ Aá‰)B–ÊcB¡à|B™êÃBœFwBxkA åíÀìXOÀÇÀ‰ûA~¹'Aè ¬Aß7·AÜg™AÙÃAT>ÇÀYÏÀ²|ûÀ©=VÀ–5÷À•ÄèÀ˜º^À›%|À€‘Àn#ÿAçû:B¶hBÜÝúBÚ¡%BØqB¸Ü8A®”ØÀê?ÀÍ­îÀ¹ÿŒÀš’¥ALœ—BÿB ÇåBq©BسA½ãÒ¾ËÅnÀÚ2Àò%À熘À³ÖðA‚ÎBžÅIB¼âËB¸IùB¸gB§t/A¼&äÁ y0ÁžÈÁv(Á´©Á g¿Œ¶pA¡¹öAÅ|iAÅëXAÒœLA²ÿ¡@X¤îÀãÃÀügÁ¨Á÷ÁXB¿Ô@¾“@ç$–A—‰@å$G@QWÀé EÁ@À”9A¸y‡BõB*}³B<'ìBBb)B iíBœ¬‚ChiC ØCÕ–CÛ›B¬,yA6«³ÁrcÁ ÃZÁ.HÁišÁ 0äÀøA`Àíù)ÀÿŠ«Á²QÁ¯‘Á2ðÁ&XFÁ xÁ!\Á#ÑiÁBÀ®ÇÑ@ÙáÁA0û§A0ÃæA4f1Aî¼À (|ÁÿoÀÀöÛA°ËÊBFê!B›}B‚¯ŒBƒ–B5„MAŸÀœAö BD.…BZÙB`ø¯B“>BŠ+¯BGÿôB.ö‘BŠ6BH ˜B/œB*ƒ¥Aö:b@Þ21À¾CÁ3Á&ZnÁìÁÁJ+Áù„AsÚA‡õŒAf%Z?ƒ_‹À’ö†?Üz @·‹)@Ážã@µ-¿@¦w`?±œÜÀ†øÀ¦‹ŽÀ´¤–À²ÕÀ­v;ÀÁ£MÀЧ[ÀÍèÀÉ2ãÀð¸¦Á;Á_ÕÁ¸™Áµ Áz·Á"ÇÁ– À¸™A“4B}ÙBè.B´Bå‰A´„Ú¿ÎÐ)À¡½@5š¨AzAa›>Asm4A‰EØA€ný@€R ÀYûDÀrøPÀhÏ6À›üÎÀ}bÀƒxÀasÀlðŠÀ†^}À\ £ÀNÀ¦æêÀaMÀAáù¼B–ãAB¡ÿ’B™úBœPØBx€­A%ÎÀëì0ÀÄËïÀ‡§tA~ÊAèÐAßcAÜ¢ÒAÚ¿AT¬ÀWf³À²OÀ¨‚^À•ÍÚÀ•A³À˜5?À™;zÀ}ÅÀlÁlAèÓB·BÜÜ*BÚ¹îBØxëB¸Þ£A¯^ýÀé„KÀÌÀÌÀ¹îÖÀ™:+AM)DBþßB ß›Be2BÜÑA½™S¾¯úÕÀÙÚÀòi'Àæ¢À³ÓA‚TGBž«(B¼ôdB¸D¯B¸]CB§wZA¼—ŸÁ 8Á)wÁH¥ÁzvÁt¿‰ZA¡äLAż«AÆGÄAÒØqA³I§@[ï¼ÀᨽÀû°ÄÁ×ÁâÚÁ÷æ¿ÓdÀ@¿°ˆ@ç¯üA´ò@åŲ@S59Àèz9Á€fÀ’ƒ^A¸»B gB*€•BAÇ À뵸Àç‚À†ñkA~Ò±Aèè·AßxéAÜÀ¢AÚ(ãATã ÀV0ZÀ±ÇvÀ¨#ÿÀ•™’À”ÿ«À—ñþÀ˜DjÀ{6ÀlšAè bB·SBÜÛ@BÚÆkBØ|ìB¸ßÑA¯ÄøÀé>+ÀÌI%À¹æpÀ˜Œ‚AMp,BþÊB ë…B^âBÞêA½sɾ¡øwÀØš?ÀòUiÀæ/wÀ³ÑoA‚sqBžžB¼ýFB¸BB¸XMB§xçA¼Ð†Á ç†ÁîCÁ1×Á]#Á·L¿‡ "A¡ù¤AÅÝAÆv`AÒö¶A³nû@]˜µÀàøáÀû|~Á{áÁÒšÁÇL¿ÓQ@À@`@çö@AÛ@æ@T%œÀè/àÁÜÀ‘¦PA¸…ÐB8B*‚ B<ƒBB?B u-Bœ˜4CfÙC æCÙCÝ©B¬\òA9 úÁÎîÁ „WÁ›tÁì Á ¢XÀø&#Àë@8Àû&äÁ<¯Á¼ÙÁ/óüÁ$[<Á ?Á!YÁ#=0ÁçïÀ­Wª@ÚãÞA1‰•A1P_A4Š A»ÀÓÆÁ)ÀÀ®A°náBFò/B²B‚ÉÑB·B5>A :AöB¼BD*BZbWBa"B“?€BŠK!BH)B/!B*­ÀÇ©=ÀíäÁÁoAÁVÁO6ÁšIÁXXÁ MçÁ§®À¶˜:A“Ì‚BË»BÁB´8B3žAµ"á¿ÅbÀŸË¹@>ÁqA|­NAc•(AuRoAŠ$vA€ä @„/ÊÀW`üÀqÐÜÀeE À™ÞÀ{à§À€ÐúÀ_2‚Àh¤ÇÀ„÷ÀXbõÀ{°À¥ßÔÀ_ÆAâkÕB–übB¢óBš  Bœ[gBx•ÑAi^Àë~ùÀ„À†:2A~Û`AéAߎÏAÜÞ–AÚK4AU[ÀTø“À±ŠEÀ§ÅÀ•e%À”½YÀ—®FÀ—KûÀy ÀkZÃAèB·¤BÜÚSBÚÒùBØ€öB¸àûA°+ŽÀè÷ôÀËÐÄÀ¹ÞÀ—ÝçAM·tBþµB ÷yBX„Bá A½N¾“âºÀØÀòA€Àå»ÃÀ³ÏñA‚’åBžËB½7B¸?^B¸SPB§znA½ ÈÁ ¶±Á²³ÁÁ?©Áh±¿…ÀÇïA¸‰áB$B*ƒ…B<¢iBB±B yBœ‘gCfXC 'TCÚ)CÞ]B¬mAA9Ú Á—ÕÁ o6Áj ÁÁçÁ reÀøËÀêUˆÀù¬KÁhgÁ§Á/:=Á#¯ºÁäÁ!'Á# *ÁÉ¥À¬ÛO@Û;&A1¹ŒA1³A4–#A)~À ŒÁáÀÀlšA°O˜BFôöBºaB‚Ò©BÈdB5¥›A +AöS2BD(œBZ{nBa0B“?÷BŠU»BH6åB/0>B*Â4Aöq@àçÂÀ}°þÁÛÔÁ%CÚÁˆÁS Á5ÇÁa5As“A‡Ü’Af?‡SšÀ’-ï?Ý`‰@·t@Á‡ª@µ¹Ô@¦î1?µ® À† gÀ¤ÅÃÀ²ÛÀ±·ÍÀ«éÑÀ¿mÀÎ'ÀÊ¿­ÀÆâÐÀìw°ÁÖèÁyÁ˜ìÁ ¨ÁÅÿÁ â¡Á/yÀµ•iA“óƒBó B.ABÇžBZÿAµrŒ¿À5ÃÀžÐà@C^=A}øÝAd”{AvG5AŠ” Aø@†"šÀVúÀq;†Àc|]À˜ÍÀ{•Àh‘À^> ÀfzÀƒô€ÀVŠÀy”ðÀ¥[mÀ_rAâ¥tB— B¢.ÀBšBœ`¿Bx eA ‡ÀëGôÀÁYõÀ…ËA~ä#AétAߤËAÜü­AÚm´AUQîÀS¿_À±L½À§eyÀ•0’À”z½À—jÀ–R,Àvü1Àj¥çAèB·÷BÜÙdBÚß—BØ…B¸â A°’¿À豤ÀËW©À¹ÕŒÀ—.ZAMÿBþ B wBRBã1A½(!¾…¹›Àן*Àò-lÀåGeÀ³ÎA‚²¢Bžƒ‡B½7B¸<²B¸NNB§{ñA½CeÁ …¹ÁvÅÁ$Á" Á¡¿ƒU]A¢$­AÆzAÆÔbAÓ3§A³ºC@`ñÊÀß–tÀû ÁÂüÁ±µÁe?¿ÒFç@ÁbR@èƒëAàÓ@æºÙ@V À癈Á~ŒÀè;A¸ïB0B*…B<ÁjBBÄöB |ìBœŠ—CeÚC -ÌCÛPCßB¬}¤A:¨Á`mÁ ZÁ8kÁ—{Á B:ÀøRÀéi§Àø/²Á’ëÁk{Á.pÁ#NÁ¸ËÁ!.ÕÁ"ØÔÁ«=À¬^#@Û“ A1é×A1¯GA4¢RA8NÀ@*Á™+ÀÀI-A°0'BF÷ÊBÂ-B‚ÛBÙÉB5®A EìAöcÅBD'+BZ”§Ba>B“@oBŠ`dBHDÊB/>ôB*×JAö„@áÑxÀ{½<Ár‡Á$åÛÁT·ÁÁÁ.ÉÁ-äAs{A‡ÔAfî?ˆ§[À‘êr?Ý®@¶íÓ@ÁÍ@µèó@§P?· (À…½fÀ¤,åÀ²@¿À±W™À«dÀ¾ÕÀÍOpÀÉòõÀÆQÀëŒÁ=§ÁÔÁÁá‘Á|1Á2àÁ vÍÁ¶œÀ´‘A”ÀB›BEæBÛB‚™AµÂ¦¿»J¦ÀÔ@HNAFAe•bAw=lA‹\AZ*@ˆ ÀT¿Àp¥Àa±À—¹þÀz[–À}+èÀ]HAÀdK÷Àƒ$ÀT®‘Àw§ËÀ¤ÖsÀ^9ÇAâßuB—ÇB¢>¡BšrBœf"BxªûA°Àë¨ÀÀ0ÔÀ„È5A~ìüAé2AߺÝAÝçAÚcAU‰ÇÀR„½À±ÝÀ§TÀ”ûØÀ”7ÙÀ—%qÀ•VýÀtì»ÀiðAèB¸KBÜØtBÚìFB؉"B¸ã@A°ú‹Àèk;ÀÊÝÕÀ¹ÍÀ–}ÚANG(Bþ‹B BKŸBå_A½¾nú8À× ±Àò.ÀäÒ^À³ÍvA‚Ò¨Bžv3B½FB¸:B¸IFB§}mA½}]Á TÁ:{Áí>ÁDÁÊ¿jÎA¢:^AÆ?uAÇÈAÓRRA³à7@b¡æÀÞãäÀúÝÚÁeÒÁ¡Á3Ì¿Ñåë@Áôl@èËRAïb@ç `@VüÀçMŠÁ}ÇÀ3A¸‘øB<)B*†ƒB<à’BBØêB €ÞBœƒÂCe^C 4OCÜwCßÊB¬ŽA;wÁ(¸Á DÂÁÁlÜÁ ×Àø ·Àè|—Àö±Á¼:ÁÁUÁ-×Á"UøÁGÁ!6ŸÁ"¦0ÁŒµÀ«à%@Ûë“A2uA1ßA4®•AG+ÀtŸÁP~ÀÀ%iA°BFú«BÊB‚ä{BëAB5¶kA `õAötuBD%¿BZ®BaL-B“@æBŠkBHR¿B/MÀB*ìAö–ˆ@â¼oÀyÆÙÁ¢Á$‡IÁ!ÁÚ'Á'³ÁúNAsbüA‡Ë‘Af 9?‰üOÀ‘¦¥?ÝûÍ@¶Æ@Áwà@¶I@§>±?¸kÍÀ…n(À£“:À±¥zÀ°öØÀªÞšÀ½<ÀÌv¢ÀÉ%ÀÅRÁÀé—SÁ£~Á/mÁ)%ÁëåÁžúÁ jÁ=À³‹ A”B8BBjB]°Bî±BªlA¶/¿¶Y ÀœÖÅ@Lª¤A€JsAf—ÝAx5A‹v«A•¢@ŠÀSk<Àp ¤À_ãfÀ–¥hÀy—ªÀzëûÀ\Q!ÀbªÀ‚RnÀRÐ[Àu¸@À¤PæÀ]qýAãØB—"’B¢N”Bš!tBœkBxµ’AUžÀêÙÀ¿"À„ pA~õêAéJÁAßÑAÝ9DAÚ³@AUÁåÀQH­À°Ð¥À¦¤–À”ÆùÀ“ô«À–àUÀ”ZoÀrÚ¤Ài9Aè#\B¸¡BÜ×BÚùBØEB¸ä[A±bñÀè$¹ÀÊcFÀ¹ÄŠÀ•ÌhAN’BþvB ‘BEBç“A¼Û³¾RZzÀÖ¡—ÀòÅÀä\¬À³ÌyA‚ò÷BžhÐB½!cB¸7TB¸D8B§~åA½·±Á #^ÁýÔÁÖQÁæYÁz&¿~ù™A¢P-AÆ`¡AÇ3rAÓqA´a@dTdÀÞ0mÀú¨]Á/ÁKÁ¿Ñ„@‡F@éAýê@ç`N@WðÀçþÁ|îÀŽ$×A¸•þBHMB*ˆB<ÿáBBìîB „ÞBœ|êCdäC :ÜCÝŸCàƒB¬ž¥ArÁ"s<ÁnÀ«aV@ÜD¸A2KgA23A4ºìAVÀ§ëÁyÀÀMA¯ðËBFý—BÑÜB‚íuBüÍB5¾ÝA |Aö…CBD$WBZÇ|BaZcB“A]BŠuâBH`ÅB/\¡B+ÑAö©@㨪ÀwÍ×Áž&Á$(&ÁíÁ@Á „ÁÆrAsJÈA‡ÂõAf_?‹RwÀ‘bˆ?ÞIî@¶ú@Áoä@¶GÕ@§gT?¹ÌùÀ…­À¢øÁÀ± IÀ°•‰ÀªXÀ¼W2ÀËœ³ÀÈV Àĉ Àè$ÁmÁ‰Áo©ÁZÃÁ NÁ yÁÂêÀ²ƒ€A”iìBjyBuŸB_BÒyA¶d'¿±`ôÀ›×ƒ@QZ@A€ò¯Ag›ìAy.,A‹èŒAÑ^@Œ ÍÀRÀouÀ^3À•FÀxÒÒÀx¨ÉÀ[X®À_æÀ‘ÀPïxÀsÆPÀ£ÊÆÀ\©AãTœB—/nB¢^šBš)‡Bœq BxÀ+AûŒÀê¡@À½ÙßÀƒQ}A~þîAécžAßç@AÝWÃAÚÖLAUúIÀP /À°’À¦CBÀ”‘ôÀ“±3À–šÂÀ“\‚ÀpÅëÀh0Aè)ÉB¸ùBÜÖŒBÛÕBØ‘pB¸årA±ËóÀçÞÀÉçþÀ¹»þÀ•ANØ^Bþ`B '­B>ƒBéÎA¼µ2¾5“úÀÖ!ßÀñð2ÀãæQÀ³Ë©AƒBž[_B½*B¸4£B¸?%B§€WA½ò`Á ñûÁÀÑÁ¿[ÁÈGÁ)»¿{±A¢fAÆýAÇc`AÓ A´,Á@f CÀÝ|Àúr“ÀÿT$ÁdÁпÑ!h@Ãâ@é[BA i@ç³£@XäÐÀæ³æÁ|ÀA(A¸šBT†B*‰B=VBCB ˆéBœv CdmC AsCÞÈCá?B¬¯BA="Á¸aÁ  Á¢%ÁÁ°kÀ÷öÀæžçÀó­ãÁ >ÁjÁ,HÀÁ øÁ5ªÁ!FMÁ"?ùÁOIÀªáµ@Üž|A2|­A2?‰A4ÇWAe ÀÚ Á ¾À¿ÜÙA¯ÐáBGBÙ¾B‚özB‚mB5ÇVA —eAö–.BD"òBZáBah­B“AÔBŠ€¸BHnÛB/k—B+BAö»¬@ä–'ÀuÒ5Á3Á#ÈpÁ¸ÎÁ` Á<Á’PAs2zA‡ºGAeþa?Œ©ÒÀ‘?Þ˜d@¶uÁ@ÁgÙ@¶w˜@§:?»/­À„Î÷À¢]{À°l+À°3¬À©ÑÀ»q'ÀÊÁ¢ÀÇ…ÝÀþmÀ殤ÁltÁá¶ÁµÁÈÌÁtÜÁ /úÁHÀ±z`A”‘ÜB’ÆB²B%Bú¿A¶µ¿¬b^ÀšÖÈ@V A›½Ah¡Az(µAŒ[A‚ _@ŽÀP½ÚÀnÛxÀ\@…À”w•Àx ÀvbSÀZ^æÀ]®EÀ€«~ÀO çÀqÑüÀ£DÀ[ßAãÂB—<[B¢n³Bš1ªBœvBxÊÆA¢eÀêi"À¼¬ À‚”ZAAé|ŸAßý’AÝvfAÚù…AV2óÀNÌCÀ°S.À¥áUÀ”\ÉÀ“mrÀ–T¸À’]5Àn®ÀgÈ=Aè0cB¹RBÜÕ•BÛµBØ•£B¸æ„A²5Àç—mÀÉküÀ¹³jÀ”f­AO!ŠBþKB 3ÓB7àBìA¼Ž€¾¦¹ÀÕ¡‡ÀñÛtÀãoMÀ³ËAƒ4rBžMÞB½3ÉB¸1ïB¸: B§ÃA¾-jÁ ÀtÁƒpÁ¨^ÁªÁØÜ¿w,äA¢|$AÆ£‹AÇ“‘AÓ¯A´SV@gÀƒÀÜÆÍÀú<{Àþ–öÁn\Á¿нá@ï>@é£ËAà@è`@YÚ‚ÀæfBÁ{ÀŒ\%A¸þB`ÔB*‹B=>óBC(B Bœo-CcøC HCßòCáüB¬¿ôA=êÁÀÁ ™Áo˜ÁëÍÁaÀ÷ìÀå®GÀò)GÀþaäÁ ½Á+‰ÁÁ HxÁ Á!N/Á" gÁ0dÀªaC@ÜøàA2®GA2p A4Ó×AtÀ Á tjÀ¿¸A¯°ÏBG”Bá¨B‚ÿ‹B‚ !B5ÏÖA ²ÍAö§6BD!’BZúÖBaw B“BKBŠ‹BH}B/z£B+,ÑAöÎM@儿ÀsÓóÁÇjÁ#h)Á„+Á"‡ÁÛÁ]éAsA‡±‡Aeø??Ž`ÀÙ]?Þç/@¶MW@Á_½@¶§’@§¹b?¼“èÀ„À¡ÁhÀ¯Î"À¯ÑBÀ©I]Àº‰õÀÉåqÀÆ´†ÀÂòªÀå7/ÀÿŸ&Á9RÁùÁ6ÁÞ£Á ÁìÁ̘À°o«A”ºB»SB¥êB*B#>A·f¿§]LÀ™Ô•@ZÌFA‚EœAi¨ÇA{$¯AŒÎA‚I¤@ÀOdKÀn@ÆÀZk]À“^XÀwF\Àt™ÀYcÊÀ[s.À¬eÀM%¨ÀoÛBÀ¢¼ÎÀ[ëAãËJB—IYB¢~ßBš9ÞBœ|BxÕbAJ*Àê0¾À»|¥ÀÖ A5Aé•ÄAàúAÝ•+AÛîAVkãÀM‹êÀ°ïÀ¥~ÒÀ”'wÀ“)hÀ–8À‘\‰Àl””ÀgEAè7)B¹­BÜÔBÛ¦BØ™ÞB¸ç’A²ŸÈÀçP¡ÀÈïAÀ¹ªÎÀ“²eAOkBþ5B @B1/BîXA¼gœ½÷%oÀÕ ÀñÆŒÀâ÷žÀ³ÊŠAƒUBž@NB½=B¸/9B¸4ëB§ƒ*A¾hÐÁ ŽÊÁE³Á‘XÁ‹±Á‡ˆ¿s<2A¢’MAÆÅHAÇÄAÓÎQA´z!@iz$ÀÜ£ÀúÀýØÕÁ]3Ák/¿ÐY€@ÄDZ@éìµA)N@è[„@ZÑÀæÁyìÀ‹uÏA¸¡ùBm7B*Œ¨B=^·BC)]B ‘'BœhHCc…C NÀCáCâ¼B¬Ð¹A>½ÁFÐÁ ïÁ<ÐÁÀbÁN À÷áúÀä¼xÀð¢«ÀüªäÁ ôÁ*ɵÁ—yÁÝEÁ!VÁ!؇ÁaÀ©ßÿ@ÝSâA2à5A2 øA4àjAƒÀ:ØÁ *`À¿’êA¯”BG¥BéšBƒ¦B‚1éB5Ø\A ÎTAö¸[BD 6B[µBa…‚B“BÂBŠ–’BH‹8B/‰ÄB+B}Aöàø@ætçÀqÓÁ[)Á#OÁO2Áä¶Á aÁ)Bº BÜÓ¢BÛ,¨BØž"B¸èšA³ ›Àç ¾ÀÈqÌÀ¹¢+À’ý*AOµBþ B L=B*qBð§A¼@†½¼¯éÀÔžøÀñ±yÀâFÀ³Ê;AƒwBž2°B½FjB¸,B¸/ÆB§„ŒA¾¤‘Á \ýÁ™ÁzKÁm,Á5Á¿oD›A¢¨“AÆç6AÇô¿AÓí¥A´¡"@k6&ÀÛY’ÀùÏbÀýÀÁKèÁ8T¿ÏôF@ÄÚ7@ê6A7µ@è°@[ÈÀåÉSÁxÅÀŠŽ&A¸¥ðBy¯B*Ž:B=~¡BC=£B •YBœa`CcC UuCâHCã}B¬á‘A?‘ Á “Á ÙÁ ÎÁ”ÅÁ¦À÷×·ÀãÉxÀïÀúñ|Á _êÁ*ÁåÁ°ÉÁ!^Á!¤WÁò>À©]é@ݯ„A3vA2ÒA4íA’9Ài€Á ßþÀ¿mnA¯p1BG ÃBñ“BƒÍB‚CÄB5àêA éûAöÉžBDÝB[.µBa” B“C9BŠ¡•BH™B/˜ûB+XHAöó®@çf,ÀoÏÁîQÁ"¥äÁäÁ¦—ÁÏÁôIArèöA‡ŸÐAeëŽ?·ÀNò?ß…Ã@µûê@ÁOX@·)@¨ x?¿`ôÀƒÞiÀ †ÚÀ®IÀ¯ ÄÀ¨8CÀ¸¸ÀÈ)©ÀÅ`ÀÁWîÀâBÀý&2ÁåxÁÁ èÁ¯ßÁ ä&ÁÓ¦À®U†A• B ,BÖÈBRBtèA·¬b¿?®À—ËÆ@dW`Aƒ›ÎAk»òA} ôAµÇA‚Âþ@”ÖÀL«sÀm,ÀV¹œÀ‘'4Àu¶4Ào{WÀWi”ÀVó5À|OìÀIQ#ÀkæžÀ¡¬‹ÀYzHAäCB—c‡B¢ŸqBšJwBœ‡aBxêžAœxÀé¿$À¹&À€UÙA#ÒAéÈ|AàA AÝÓ AÛdJAVÞ”ÀKîÀ¯”kÀ¤¸À“¼cÀ’ xÀ•ÓÀWÀhXµÀe—EAèE;BºhBÜÒ¥BÛ9ºBØ¢nB¸éžA³v ÀæÂÁÀÇóÀ¹™À’FýAOÿSBþ B XB#¥BòüA¼?½ìáÀÔÁÀñœ;ÀâDÀ³ÊAƒ˜ÏBž%B½OÐB¸)ÈB¸*šB§…èA¾à­Á + ÁÉ"Ác6ÁN‚ÁㆿkFA¢¾÷AÇ UAÈ%»AÔ A´ÈX@lôŠÀÚ¡›Àù˜aÀüY¸Á:}Á0¿ÏŽ2@ÅpÕ@ê«AF@é@\ÀæÀåz Áw‰À‰¥)A¸©ãB†;B*ÐB=ž³BCQúB ™˜BœZsCb¨C \5CãtCäAB¬ò}A@eüÁÔÁ ÃÝÁÖÁhôÁêõÀ÷ÍRÀâÕHÀírÀù5¬Á ¯æÁ)FyÁ2½Á„Á!f Á!oØÁÒýÀ¨Û@Þ ÄA3E A3iA4ùÍA¡bÀ–ÿÁ •EÀ¿G›A¯O¥BG ìBù“BƒB‚U³B5é~A¡ÂAöÚþBD‰B[H×Ba¢¬B“C°BЬ§BH§ÖB/¨FB+n1A÷m@èX²ÀmÉoÁ€âÁ"CçÁäAÁh*Áû#Á¿ArÐBA‡–ÙAeäÿ?’=À D?ßÕŒ@µÒè@ÁG@·8Æ@¨6g?ÀÉÆÀƒÁÀŸè_À­îzÀ®¦±À§®ÔÀ·ÍwÀÇJÀÄ9’ÀÀˆöÀàÄUÀûçÁ:Á ÀCÁxœÁTÁ tmÁV2À­FA•3ðB6wBïnBf-BžA·ÿ‡¿˜'#À–Å)@i&UA„H!AlÇåA~!@AŽ*„Aƒ@–©ÀKL)ÀljCÀTÝÀ NÀtì½Àm'ÏÀVj{ÀT®TÀzž ÀGbÝÀièµÀ¡#ŽÀX«ÊAä€,B—p¸B¢¯ÖBšRÜBœBxõ>AGÀé…íÀ·å À'÷A-AAéâAàW²AÝòNAÛˆ=AWTÀIÂLÀ¯T%À¤SºÀ“† À’[‘À•7îÀŽRFÀf6ÓÀdÚA¿$Á ø÷ÁŠNÁLÁ/±Á׿g@¾A¢ÕyAÇ+¤AÈVûAÔ,´A´ïÄ@nµOÀÙè¾ÀùaÀû˜¼Á(ïÁÑÄ¿Ï'E@Æ4@êɸATi@éZ]@]º"Àå*3Áv:ÀˆºÙA¸­ÒB’ÜB*‘iB=¾ëBCfaB ãBœSƒCb=C cCä CåB­}AA;éÁš,Á ®(Á£Á<ðÁ¹ À÷ÂËÀáßèÀìÔÀ÷wuÁ þçÁ(ƒHÁ~ÿÁW:Á!n Á!; Á³œÀ¨WJ@Þh¤A3wôA35A5A°—ÀÃUÁ J4À¿!oA¯.òBG"B€ÎBƒ$=B‚g¶B5òA¡!©Aöì|BD9B[cBa±bB“D'BŠ·ÉBH¶>B/·¨B+„8A÷7@éL|ÀkÀ­ÁÜÁ!áXÁ®HÁ)oÁó_Á‰’Ar·sA‡ÐAeÞL?“p˜ÀÃF?à%ª@µ©³@Á>µ@·iš@¨`—?Â4Àƒ<ÝÀŸIÀ­L¿À®BÀ§$ÎÀ¶áªÀÆi]ÀÃcœÀ¿¸ìÀßDÀú¥þÁˆÁ dÁâ{Á~Á %ÁØÀ¬5A•] B`B 9BzkBÇwA¸S¿“À•½@mûA„õFAmÕmA"ýAŽŸÒAƒ=l@˜"ÀIê÷ÀkËHÀRýñÀŽéÛÀt"YÀjÑÀUj ÀRf/Àxé¸ÀEqèÀgèfÀ ™ýÀWÜ-Aä½;B—}ùB¢ÀNBš[RBœ’ÏBxÿàAòuÀéLqÀ¶¯cÀ}¡ÝA6ÅAéûÄAànpAÞŸAÛ¬_AWR[ÀH|<À¯ˆÀ£îØÀ“P·À’bÀ”ï“ÀLÀdOÀd.AèSþB»(BÜÐ¥BÛTBØ«B¸ë˜A´N¶Àæ4ÀÆõÀ¹ˆÀ×ËAP•BýÞB q'BäB÷¼A»Ê»·äÇÀÓuÀñq@ÀáCÀ³ÊUAƒÝ%Bž {B½bÉB¸$NB¸ 2B§ˆA¿Y÷Á Æ¿ÁKÁ4ôÁ»Á=´¿c4wA¢ìAÇN$AȈAÔLnAµf@pxuÀÙ.úÀù)vÀúÖÍÁAÁž¿Î¿@Æ S@ë%Ab·@é°@^´@ÀäÙÏÁt×À‡Ï5A¸±¾BŸ’B*“B=ßKBCzØB ¢;BœLŽCaÔC iÔCåÎCåÏB­ABÒÁ`Á ˜cÁoeÁºÁ†ìÀ÷¸#ÀàéYÀêt6Àõ¶ÖÁ LïÁ'¿ ÁÊXÁ*)Á!vÁ!íÁ”À§ÒÀ@ÞÆ#A3«1A3fÜA5A¿Ù¿ÿÝÁ þÌÀ¾úìA¯BGdB€ÕBƒ-†B‚yÍB5ú»A¡=¯AöþBDìB[}~BaÀ,B“DžBŠÂùBHĶB/ÇB+š^A÷, @êA‡ÀiµLÁ¤@Á!~6ÁwùÁêfÁë‚ÁSÎArž‹A‡„µAe×u?”Ï'À|ø?àv@µ€M@Á6L@·š¤@¨‹ ?ßþÀ‚ë½Àž©À¬ªÀ­ÜâÀ¦š2Àµô·ÀŇ…ÀÂŒ~À¾çÒÀÝ´Àùc,ÁàÁ ?sÁK„Á ãéÁ“PÁYPÀ«"xA•†aB‰ËB !)BŽÁBñA¸§¿â•À”³ˆ@r×A…£B/Ö«B+°¡A÷>ê@ë7ÕÀg§LÁ5 Á!ƒÁAVÁ«ÁãŒÁÅAr…‰A‡{ˆAeÐy?–.èÀ6Y?àÆä@µV³@Á-Ó@·Ëå@¨µ¿?Å eÀ‚š`ÀžÀ¬„À­w%À¦ÿÀµžÀĤŒÀÁ´8À¾¦ÀÜ>ÅÀøŠÁ1Á }rÁ³¸Á I Á!ìÁÙãÀªKA•¯óB³ÔB :=B£/BìA¸û’¿ˆ¶’À“¨ƒ@w¸ÓA†RAoõ8A€•dAŒ'Aƒ¸ì@œ>äÀG"×ÀjŠÀO8\ÀŒ¦LÀrŠÌÀfÀSe5ÀMÌÀuyÉÀA‡÷ÀcàšÀŸ…$ÀV9™Aå8}B—˜®B¢áwBšlpBœžkBy)AL"ÀèØ¥À´?ZÀzŽ‘AJ Aê/œAàœ-AÞP«AÛõ/AWÇ9ÀEëÒÀ®‘FÀ£#NÀ’äsÀ‘‹&À”]xÀ‹;©À_ÁaÀbAèctB»ïBÜÎBÛn§BسñB¸í~Aµ)ÏÀå¥ÚÀÅóŸÀ¹v‰ÀdÑAQ,UBý±B ‰õBìBü–A»z5=XL¡ÀÒ «ÀñE›ÀàšÀ³Ë@A„"¡Bí·B½uüB¸ÍB¸±B§‹!A¿Ô®Á aäÁ˧Á’ÁÒ[Á–¿[;A£²AÇ“µAÈìQAÔŒIAµgJ@tåÀ׸¿Àø¹TÀùPÁóÁ5Ï¿Ííf@ÇÒÔ@ëª"A:@ê\Ø@`«$Àä7cÁqÖÀ…óòA¸¹ŠB¹ BC£øB «Bœ>™Ca C w›Cè+CçdB­6ñACÙÁêÆÁ l§ÁOÁ·´Á"À÷¢mÀÞøªÀçPøÀò._ÁæÁ&3iÁ^JÁÏpÁ!†HÁ šÅÁTÁÀ¦Ç8@ß‚þA4¦A3ËRA5-…AÞƒ¿ü‚ÃÁ f÷À¾¬ÞA®ËäBG B€ ðBƒ@:B‚ž5B6 A¡vA÷!¤BD`B[²ªBaÞB“EŒBŠÙˆBHáÖB/æLB+ÇA÷QÓ@ì/fÀe–«Á ÅAÁ ¶>Á \ÁkjÁÛ}ÁçuArlmA‡rHAeÉZ?—ÝÀŽïk?á@µ,è@Á%K@·ý]@¨à¶?Æ|SÀ‚HÇÀfnÀ«bÀ­ÛÀ¥ƒ6À´]ÀÃÀrÀÀÚÊÀ½BhÀÚ¸ÃÀöØÁõÁ º`ÁÁ ­fÁ¯ùÁYÏÀ¨øŠA•ÙÀBÞB SvB·¶BDüA¹Pt¿ƒ„À’œ@| ÜA‡Aq|AkA,Aƒ÷@žQ9ÀE»êÀiçéÀMQÙÀ‹‚0Àq½¢Àc¹ÀR`ËÀKz,Às¾+À?ŽûÀaÙÀžùÛÀUf¢Aåv±B—¦!B¢ò(BšuBœ¤IByÏAúZÀèžVÀ³üÀy^ASÐAêI¿Aà³+AÞpfAÜÜAXÀD¡xÀ®O¢À¢¼¦À’®À‘EÀ”¸ÀŠ1`À]”÷ÀaÛãAèkqB¼UBÜÍ—BÛ| BظgB¸îjAµ˜DÀå^cÀÅqÏÀ¹m¹ÀŽ©èAQx‡Bý›B –kBÛBÿ A»Q÷=¨lâÀшWÀñ/ˆÀߟGÀ³Ë÷A„EÍBß¿B½¬B¸ B¸hB§ŒbAÀ“Á /BÁ‹`ÁïUÁ²ñÁA“¿VæEA£0¬AǶÆAÉŸAÔ¬iAµŒ@uÐ.ÀÖüHÀø€ÏÀø‹IÁánÁC¿Íƒ@Èm5@ëõ²Ao@ê³Ð@a§éÀãåZÁp8À…TA¸½jBÆ0B*—ïB>ASBC¸¡B ¯ŽBœ7™C`§C ~Cé[Cè2B­H?ADvÁ¯±Á V±ÁÒëÁŠåÁï=À÷—_ÀÝþŠÀå¼YÀðfˆÁ1&Á%lÁ¦äÁ¡ÊÁ!ŽlÁ d»Á4åÀ¦@9@ßâZA4FÞA3ýíA5:¦Aíê¿úÒ(Á ‰À¾…SA®ªBGsB€BƒI¤B‚°‡B6ÉA¡’A÷3—BDB[ÍrBaí B“FBŠäåBHðB/öB+Ý‚A÷dÆ@í(9ÀcƒkÁ TßÁ QgÁÓÁ+wÁÓVÁ°àArS8A‡h÷AeÂ?˜òÀލ-?áir@µê@Á´@¸/ @© ï?ÇìÉÀöñÀœÃñÀª¼˜À¬ªÀ¤öÖÀ³&÷ÀÂÛ6ÀÀ5À¼nÀÙ0¬ÀõÖÁÑcÁ ö>Á Á ûÁ=xÁÙÀ§á5A–ÊB¤B lÔBÌTBoFA¹¥Å¿|–(À‘Ž@€Ç–A‡²ArTAœ+AzÄA„5€@ f.ÀDSÀiD¤ÀKhÛÀŠ\‡ÀpïŒÀaU&ÀQ[ ÀI$úÀrÀ=“QÀ_Ï8ÀžmÿÀT’AåµGB—³¦B£ìBš}ÐBœª3By*wA©~ÀècÁÀ±É ÀwqÎA]ªAêdAàÊ?AÞCAÜ>¸AX=.ÀCU±À® ¦À¢UgÀ’w—ÀþÅÀ“É‚À‰%¸À[eìÀa¿AèsšB¼¼BÜÌŽBÛ‰BؼåB¸ïRA¶TÀåÓÀÄïFÀ¹dàÀî AQÅBý„B ¢ëBù½B‹A»)‡=åõÀÑcÀñKÀß"KÀ³ÌÙA„iABÑ·B½‰jB¸DB¸ B§AÀPÓÁ ü|ÁJ¼ÁØÁ“bÁì ¿R¾jA£GÃAÇÚAÉQ1AÔÌ«Aµ¸@wœÙÀÖ>êÀøGüÀ÷ÅŒÁÏ;ÁÌn¿Íè@ÉX@ìA£A›œ@ë /@b¥‘Àã’ÄÁn†À„bA¸ÁGBÓ:B*™šB>bOBCÍZB ´Bœ0•C`HC …ŒCêŒCéB­Y AExOÁtOÁ @ªÁžMÁ]ãÁ¼>À÷Œ0ÀÝ;Àä%¸ÀîœIÁ{DÁ$£•Áî”ÁsñÁ!–˜Á .bÁêÀ¥¸i@àBUA4{jA40ÉA5GÚAý_¿ù:Á ÍÄÀ¾]pA®‰BG æB€BƒSB‚ÂìB6†A¡¯A÷E§BDãB[è[Baü,B“FyBŠðRBHÿ9B0ÏB+ôA÷wÃ@î"OÀamŠÁ ãæÁëÿÁ›jÁë7ÁËÁzAr9éA‡_“Aeº®?šUaÀŽ`ž?á»8@´Ø¹@Á @¸`ð@©7j?É^ÆÀ¤àÀœ ¦Àª?À¬BŸÀ¤ißÀ²5iÀÁôÙÀ¿$xÀ»˜ºÀצ€ÀôEÄÁÌÁ 1 ÁçTÁ sÉÁÊiÁW®À¦ÈLA–.B3lB †VBá B™ÈA¹û†¿r1À~¡@ƒAßAˆcCAs0¿A‚ £AòîA„t1@¢}ÃÀBèTÀh MÀI}cÀ‰5QÀp ‰À^îÀPSùÀFÌ„Àp?¤À;”ùÀ]ÂðÀáÀS½ZAåô>B—Á;B£ÃBš†™Bœ°(By5!AYŽÀè(æÀ°‹ŒÀußàAg™Aê~qAàáiAÞ°CAÜcÂAXx‘ÀB|À­ËSÀ¡íÀ’@ñÀ¸'À“~ÕÀˆ°ÀY4?À`V•Aè{ðB½%BÜ˃BÛ—BØÁkB¸ð5A¶wÀäÏ*ÀÄlÀ¹\À1@ARBýnB ¯uBòBA»æ>ñEÀÐ{ÐÀñãÀÞ¤¥À³ÍæA„ŒÿBáB½“7B¸|B¸ÄB§ŽÓAÀnÁ É’Á ¼ÁÀÃÁs¬Á—9¿NªA£^øAÇý{AÉ„AÔíAµà²@ykåÀÕ€¦ÀøÛÀöþÛÁ¼æÁ—R¿Ì«â@ɤ:@ìôA©À@ëbö@c¤Àã?¢ÁlÁÀƒ!A¸ÅBàWB*›GB>ƒqBCâ$B ¸°Bœ)ŒC_ëC Œ“Cë½CéÔB­kAFT%Á8žÁ *“ÁitÁ0®Á‰À÷€ßÀܼÀâÀìÏ£ÁÄhÁ#ÚÁ5ZÁEçÁ!žÍÁ÷¹ÁôÐÀ¥/Ç@à¢ðA4°JA4cæA5U#A à¿÷iûÁ €¨À¾55A®glBG$eB€5Bƒ\›B‚ÕfB6&JA¡Ë©A÷WÔBD«B\fBb aB“FðBŠûÎBIB0±B, ÛA÷ŠÊ@ï§À_U Á rVÁ†ÁcpÁª¨Á¼ÁBåAr €A‡VAe³!?›¹ïÀŽ¿?â R@´®V@Á V@¸“ @©c(?ÊÒJÀR‘À›|ŽÀ©núÀ«Ú¬À£ÜRÀ±BµÀÁ [À¾G”ÀºÂHÀÖAÀòùâÁm/ÁjÈÁL3Á ÕÒÁVËÁÕ¡À¥­ÏA–XB^rB ŸýBõØBÄ„AºQ¶¿g‹?Àmº@…¿LA‰QAtG¿A‚¥ÓA‘kªA„³'@¤—øÀA{«ÀgúãÀGqÀˆ ÀoPšÀ\ƒÀOK‘ÀDpËÀn|ºÀ9“ôÀ[´BÀTÀRçAæ3—B—ÎáB£$­BšrBœ¶(By?ÌA ŠÀçíÄÀ¯L{ÀtK”AqAê™Aàø¨AÞÐfA܈úAX´:À@¹ÙÀ­ˆ§À¡…!À’ $Àq?À“3±À‡ HÀVÿðÀ_’gAè„sB½BÜÊvBÛ¤BØÅùB¸ñA¶çFÀä‡iÀÃèÀ¹SÀŒsAR_bBýWB ¼ BëVB›AºØ>/ˆÑÀÏôÀðìQÀÞ&TÀ³ÏA„±Bµ|B½B¸²B¸jB§AÀÎeÁ –…ÁÈ_Á©oÁSÑÁA^¿JZA£vKAÈ!AÉ· AÕ ”A¶ •@{=SÀÔÁ{À÷ÕlÀö76ÁªpÁaí¿Ì?@Ê@Þ@ìÚ§A·Ý@ë»$@d£ˆÀâëóÁjèÀ‚-„A¸ÈõBíŠB*œùB>¤»BCöþB ½TBœ"€C_‘C “¥CìïCê¨B­|žAG0÷ÁüžÁ lÁ4`ÁFÁU˜À÷umÀÛ ÀàòvÀë”Á ‘Á#Á{6Á¬Á!§ ÁÀÂÁÔ—À¤¦T@á)A4å}A4—DA5bAn¿õ²iÁ 34À¾ ¢A®EžBG'ðB€SBƒf(B‚çóB6/A¡èmA÷jBDwB\’Bb¬B“GgB‹YBIÜB0%¨B,!µA÷Ü@ðAÀ]9êÁ /ÁwÁ+!ÁiÌÁºJÁ ArýA‡L•Ae«q?±ÀБ?â_Â@´ƒÁ@Á@¸Å^@©(?ÌGVÀÀš×©À¨ÆÉÀ«r+À£N.À°NÛÀÀ$¼À½i‡À¹êÆÀÔ‹íÀñ¬0Á¹ŒÁ£sÁ°<Á 7ÁâŸÁRìÀ¤‘¾A–ƒLB‰¸B ¹ÉB ¾BïzAº¨U¿\òSÀŽ[[@ˆ?ÛA‰È0Au`SAƒ+¼A‘äùA„òb@¦´ÎÀ@ ÀgThÀEŸÀ†â<Àn¾ÀZòÀNAÖÀBÏÀl·aÀ7BÀY£/ÀœÆûÀR™AæsRB—ܘB£5ªBš˜\Bœ¼3ByJxA¼rÀç²]À® ØÀr´êA{¶Aê³³AáýAÞð¬AÜ®aAXð)À?iÉÀ­E¥À¡À‘Ó1À*À’èÀ…úÀTÈÿÀ^Í2Aè"B½üBÜÉgBÛ²DBØÊB¸ñìA·X'Àä?ÀÃcOÀ¹J*À‹´ÏAR­Bý@B ȧBäB -Aº¯>NGÀÏlÊÀðÕ”Àݧ[À³Ð„A„ÕWB§HB½¦üB¸çB·û B§‘.AÁ ·Á cTÁ†¥Á’Á3ÏÁë¿FzA£»AÈDòAÉê}AÕ.Æ+BD èB ÂBœpC_9C šÁCî"Cë~B­Ž:AHÄÁÀQÁ þ4ÁÿÁ Õ«Á!òÀ÷iÙÀÚ -ÀßUÔÀé/ÁSÁÁ"CùÁÀ'Áé>Á!¯NÁ‰{Á´?À¤@áfA5A4ÊâA5oðA,¿óø†Á åiÀ½ã·A®#¨BG+‡B€!uBƒo¿B‚ú”B67æA¢QA÷|†BDFB\9ßBb* B“GÝB‹ôBI+ÆB05´B,8­A÷°ø@ñÀ[*Á qÁ¸XÁò}Á(¡Á±¿ÁÓÓAqíaA‡BúAe£œ?ž†§Àˆ?Ⲇ@´Xù@Àùº@¸÷ç@©»i?ͽéÀ€­@Àš1öÀ¨«À« À¢¿sÀ¯YÙÀ¿:ûÀ¼ŠSÀ¹1ÀÒû…Àð\®ÁäÁÛÁqÁ —ÁmåÁÏÀ£tA–®EBµ=B ÓºB½B¨Aºÿd¿RLlÀGƒ@ŠÃŒAŠ{àAvz{Aƒ²]A’^ÚA…1â@¨ÔDÀ>œŸÀf¬ÙÀC¬À…¶^Àm­öÀW¥ÀM6ÆÀ?¯ÀjïšÀ5‰âÀW·Àœ8ÔÀQ7 Aæ³nB—ê`B£FºBš¡WBœÂIByU&AoFÀçv¯À¬É£ÀqãA…åAê΋Aá'gAßAÜÓ÷AY,]À>JÀ­JÀ ²~À‘œÀâ“À’œÀ„é[ÀRlÀ^øAè•ýB¾jBÜÈVBÛ¿ûBØÏ/B¸òÁA·É£Àã÷žÀÂÝÞÀ¹A3ÀŠõ+ARû.Bý)B ÕPBܹB ÆAº…Ú>m,,ÀÎäYÀð¾­ÀÝ'·À³ÒA„ùñB™B½°õB¸B·õ¢B§’TAÁMdÁ 0ÁDŽÁz­Á§Á”L¿AÚ A£¥JAÈhöAÊAÕOA¶[ý@~çQÀÓ@rÀ÷a§Àô¥Á…!ÁöJ¿Ëbº@Ë|f@íu.AÓý@ìl¶@f¥ ÀâBïÁfúÀ€BXA¸Ð“B.B* fB>çÂBD ãB ÆÂBœ[C^ãC ¡çCïVCìVB­ŸêAHíŽÁƒ´Á çìÁɈÁ §ÝÁîÀ÷^#ÀÙ ÀÝ·2Àç[@Á™õÁ!wVÁ.ÁºŸÁ!·›ÁQåÁ“ÈÀ£ú@áÈyA5PßA4þÀA5}uA;¯¿òÀXûËÁ ÁP¨Á¹ƒÁç)Á©Á›áAqÓ«A‡9NAe›£?ŸîÏÀ?C?ãŸ@´-ÿ@ÀðÔ@¹*¦@©çî?Ï6À€Z>À™‹vÀ§s¡ÀªŸÀ¢0!À®c²À¾PÀ»©øÀ¸8ŒÀÑi Àï \ÁO6Á™ÁuÏÁ÷DÁøœÁK‹À¢TßA–ÙyBáB íÏB4ÓBFA»Vâ¿G™ŠÀŒ23@J`A‹0aAw–8A„9·A’ÙMA…q¦@ªö[À=*<Àf9ÀA¶¹À„ˆòÀlÛAÀU0ÎÀL*aÀ=J Ài%dÀ3€ÕÀUyÚÀ›ªÀP]_AæóíB—ø8B£WÝBšªbBœÈkBy_ÖA#Àç:»À«…ÞÀo€~A)Aêé‡Aá>çAß1¢AÜù»AYh×À<Å^À¬¾˜À HIÀ‘dÚÀšÏÀ’O}ÀƒÖÕÀPS7À]?¹AèŸB¾ÙBÜÇCBÛÍÃBØÓÖB¸ó‘A¸;ºÀ㯓ÀÂW´À¹84ÀŠ4•ASI¥BýB âBÕVBfAº\s>†ýÀÎ[GÀð§›ÀܧjÀ³ÓÏA…ÔBгB½ºýB¸ IB·ð6B§“tAÁlÁüˆÁÁcAÁóYÁ=¿=¶A£¼öAÈ*AÊRAÕoñA¶…@€_ñÀÒ~”À÷'OÀóÚ’ÁrGÁÀ ¿ÊóP@ÌL@íÃAâ@ìÆ@g§Àáí›ÁdæÀ~•‰A¸Ô]BŸB*¢!B? €BD5ïB ËŒBœ CC^C ©CðŠCí0B­±®AIÍTÁFÊÁ Ñ”Á“ÄÁ yÜÁ¹þÀ÷RLÀØßÀÜÀå„úÁß0Á ©§ÁGKÁ‹ÏÁ!¿ñÁÁs2À£@â+A5‡A52ßA5‹AKc¿ð}ÊÁ HÍÀ½ÚA­ßBBG2ÛB€)ÄBƒƒBƒ B6IA¢?xA÷¡®BDòB\pÝBbI B“HÊB‹*UBIIÌB0V B,föA÷×N@óŸÀVØËÁ ¦/ÁèeÁ€3Á¥cÁ _ÁcªAq¹ÛA‡/Ae“…?¡X+ÀŒö$?ãY @´Ò@Àçß@¹]œ@ª´?Я¤À€þÀ˜ä)À¦È«Àª5XÀ¡ :À­lcÀ½dÀºÈtÀ·]ÕÀÏÔyÀí¸:Á˜‚ÁGÁ ×YÁV3Á‚ÄÁ ÆßÀ¡4A—éB B  BJBq²A»®Ï¿<Ù­À‹k@ÔWA‹å´Ax³ˆA„ÁÈA“TSA…±°@­À;µðÀeZ†À?¾ÜÀƒYùÀlŸÀR¹UÀK©À:áEÀgX¿À1uÀSa˜À›ÍÀO‚–Aç4ÌB˜"B£iBš³~BœÎ˜Byj‡A×°ÀæþÀª@‡Àmâ¼AšƒAë¦AáV|AßRQAÝ­AY¥—À;qÀ¬zŽÀŸÝ}À‘-uÀRÂÀ’À‚ÂðÀN`À\wtAè¨9B¿JBÜÆ.BÛÛ›BØØ†B¸ô\A¸®lÀãgoÀÁÐÐÀ¹/.À‰s AS˜|BüûB î¾BÍåB Aº2Û>•µEÀÍÑ–Àð^ÀÜ&rÀ³Õ¶A…DB|RB½ÅB¸xB·êÃB§”AÁÍÐÁÈíÁ¿JÁKÌÁÒäÁåk¿9>}A£ÔÀAȱAʆ)AÕþA¶¯;@MjÀÑ»ÏÀöìªÀóÁ_LÁ‰‡¿Êƒ @̺ò@î8Aïü@íæ@hªÀá—¹Áb¾À|£¼A¸Ø#B#%B*£àB?+fBDK B ÐbBœ'C^?C °RCñÀCî B­Ã…AJ®Á ‘Á »+Á]ÅÁ K¨Á…°À÷FRÀ×pÀÚsëÀã¬LÁ#pÁÚëÁ‰~Á\ÌÁ!ÈNÁáÍÁR}À¢xY@âFA5½‘A5g?A5˜»A[#¿î¼ñÁùüÀ½fèA­¼ÓBG6—B€-òBƒŒÊBƒ2íB6RƒA¢\»A÷´nBDÎB\ŒŽBbX­B“IAB‹6BIXçB0fZB,~IA÷ê‰@ôDÀT³,Á 1¬Á‘ÁFŽÁcNÁ—ŠÁ+,AqŸòA‡%¿Ae‹D?¢ÂºÀŒ¬´?ã¬Ð@³×s@ÀÞÛ@¹É@ªA¼?Ò*ÍÀgÀ˜<À¦ÈÀ©Ê¡À¡»À¬sîÀ¼vòÀ¹åÉÀ¶‚ ÀÎ=ÕÀìcHÁ àÈÁ{}Á 8 Á´\Á _Á A‹À °A—0”B9IB "gB_HBŒA¼,¿2 ÖÀŠ*@’apAŒ›ÙAyÒlA…J’A“ÏëA…ñþ@¯BiÀ:?ºÀd¯ÀÀ=Ä„À‚)rÀk3ÀP>˜ÀJ œÀ8u;Àe‰«À/f²ÀQFðÀšŠîÀN¦­AçvB˜B£z\Bš¼«BœÔÐByu:AHÀæÂÀ¨ùŸÀlB›A¤òAëëAán'Aßs#AÝEÎAYâœÀ:=À¬6-ÀŸrÀõêÀ kÀ‘µ À­«ÀKÒèÀ[®)A豚B¿¼BÜÅBÛé„BØÝ>B¸õ"A¹!¹Àã4ÀÁI2À¹&!Àˆ°‘ASçµBüãB û„BÆfB¹Aº >¥aíÀÍGFÀðx÷ÀÛ¤ÒÀ³×ÈA…ivBmâB½Ï8B¸¤B·åKB§•¤AÂÁ•/Á|Á4PÁ²JÁL¿4æ^A£ì©AÈÖ%Aʺ•AÕ².A¶Ù+@‚<ÀÐø$Àö±·ÀòB¹ÁL0ÁRº¿Êî@Í[Y@î_ÏAýï@íz@i­íÀáALÁ`‚Àz¯GA¸ÛæB0¿B*¥£B?MrBD`7B ÕEB›ÿC]ðC ·—CòöCîêB­ÕoAKÕÁÌ Á ¤±Á'‹Á AÁQ+À÷:8ÀÖÑÀØÏGÀáÑ6Áf¶Á #ÁÊÇÁ-˜Á!гÁ©JÁ1©À¡êÎ@âó›A5ôgA5›àA5¦}Ajð¿ìùÆÁªÔÀ½<žA­šµ!öÀ̼VÀðafÀÛ"‡À³ÚA…4B_cB½ÙkB¸ÏB·ßÍB§–³AÂO©ÁaLÁ8“ÁËÁ‘‰Á4º¿0‡ZA¤®AÈúìAÊïDAÕÓA·P@ƒ+îÀÐ3“ÀövwÀñu_Á8òÁ¤¿ÉŸ÷@Íü€@î®ÆA Ú@íÔ³@j²©ÀàêQÁ^3Àx¸,A¸ß¤B>nB*§iB?o¥BDusB Ú5B›÷âC]¤C ¾æCô,CïÊB­çmALrÁŽ4Á Ž(ÁñÁ î¨ÁnÀ÷-ûÀÔþÀ×(£Àßó¸Á©Á:NÁ &Áþ2Á!Ù!ÁpxÁ¶À¡\r@ãXA6+’A5ÐÀA5´RAzÉ¿ë4IÁ[TÀ½ûA­w|BG>4B€6WBƒ _BƒXàB6ddA¢— A÷ÚFBD ‘B\ÄTBbx-B“J.B‹MÙBIwNB0‡3B,­GAø@ö TÀP`Á FáÁ¬2ÁÒEÁÞ<Á…”Á¹aAqkÒA‡çAezT?¥›rÀŒæ?äUT@³€@ÀÌ£@¹÷Æ@ªœ”?Õ%µÀ~­À–érÀ¤Â>À¨óŠÀŸìúÀª‘Àº™FÀ¸ûÀ´ÇIÀË PÀé³ôÁ nDÁáÁ ööÁnZÁèÁ 4êÀÈ1A—ˆŸB’ŽB W“BŠBõíA¼¹2¿L6À‡Î?@—… AŽ –A|ñA†^PA”ÈÑA†sh@³˜øÀ7M•ÀcVÿÀ9ÈdÀ‡yÀi‡/ÀK?QÀGë…À3“]Àaä8À+AÙÀM rÀ™ivÀLëƒAçù¶B˜0CB£'BšÏ5BœábByŠ£Aû:ÀæH-À¦gÀhûBAºAëVßAá½Aßµ0AÝ’šAZ]xÀ7kdÀ«¬cÀž™ŠÀ†cÀŽxâÀ‘ºÀ~þÀGHÀZ„AèÄàBÂÀ¦BÜÂãB܈BØæÇB¸ö¡Aº %ÀâŽrÀÀ7ÉÀ¹ïÀ‡(ÅAT‡HBü´B.B·?B'A¹´é>Äõ_ÀÌ0ÇÀðI©ÀÚŸ“À³ÜoA…µÁ|uÁ€AqQ›A‡ßAeq¦?§ ›À‹Î†?äª@³T'@ÀÃp@º+–@ªÊc?Ö¥tÀ}oLÀ–>ðÀ¤–À¨‡*ÀŸZ·À©ƒ¨À¹¨¾À·6ØÀ³èMÀÉmoÀèY’Á ³zÁUÁ U*ÁÊ/Á¥×Á ­žÀœ¡A—´ýB¿B r`BŸ«B"sA½Ý¿XnÀ†±–@š‹AŽÃ/A}8‘A†éCA•F A†´…@µÈ1À5ѤÀb©À7ÆœÀ}Àh¯ÚÀHºÆÀFØ{À1‰À` ØÀ)+hÀJè›À˜×ÞÀL AAè<B˜>oB£®©BšØ“Bœç¼By•ZA ³•Àæ ÚÀ¥€ÀgTAÄ¿AërAᵩAßÖjAݹFAZ›OÀ6TÀ«fûÀž,`ÀNgÀŽ/¯ÀÉàÀ|Ë@ÀDþ´ÀYL)AèÎÆBÂÁBÜÁÆBÜ¢BØë—B¸÷YAºCÀâEìÀ¿­þÀ¹ ËÀ†csAT×¢BüB"B¯—BçA¹Š‹>ÔÜ)Àˤ˜Àð1ÃÀÚôÀ³ßA…ÛBB8B½íþB·ýB·Ô¿B§˜ÂAÂÒïÁùÁ°iÁí«ÁO•Á‚8¿'´£A¤5AÉE AËYmAÖ‡A·X<@…4ÀΧ¼Àõÿ Àï×ÐÁÁ¬ ¿È¹}@ÏA@ïM×A'˜@î‹@l¾ÇÀà:·ÁYYÀtÂA¸çBZ B*ªÿB?´€BD B ä;B›éŽC]C Í£CöœCñ‘B® ¥AN:øÁÁ `ãÁƒ}Á ÜÁ²MÀ÷ÀÒðÕÀÓÕXÀÜ1…Á*ªÁ•~Á‰%ÁžÒÁ!êÁýçÁÎsÀ =E@ä$TA6šáA6;DA5Ð9Aš¢¿ç¢ZÁ»OÀ¼»¯A­1ƒBGFB€>ÌBƒ´!Bƒ#B6v_A¢ÓAø“BD eB\üŸBb˜B“KB‹eÒBI•÷B0¨bB,ܾAø7Ù@ø,nÀLqÁY¹ÁÖ‹Á\¥ÁWòÁs<ÁFAq7JA†ýÆAehÔ?¨x÷À‹ƒÖ?äÿ+@³'þ@Àº-@º_@ªøt?Ø&ºÀ|ÆsÀ•“¡À£dÀ¨<ÀžÇÞÀ¨†™À¸·À¶OŽÀ³?ÀÇÎyÀæýaÁ ÷ªÁB|Á ²‰Á%?Á-8Á %©À›xbA—á˜BìÐB QBµRBO3A½lö¿W«À…“s@œµ.A|™A~]ÆA‡tîA•ÄA†õæ@·ú À4SËÀaùóÀ5ÂZÀz¯¢ÀgךÀF2÷ÀEÄÀ.¤qÀ^5 À'JÀHÄ_À˜E´ÀK+àAè~æB˜L­B£À>BšâBœî!By A!lÛÀåÍAÀ£ÎSÀeªqAσAëŽeAáͪAß÷ÈAÝà!AZÙkÀ4µÕÀ«!;À¾žÀEÀæ2ÀzÀz•ºÀB²´ÀX~ÉAèØØBÂÁ•BÜÀ§BÜ!ÎBØðpB¸ø AºôüÀáýNÀ¿#zÀ¹ŸÀ…/AU(^Bü…B/B§âB¯A¹_û>äÖTÀËÉÀð±ÀÙ—¬À³áÄA†(B3ŒB½ø]B·úBB·Ï/B§™ÂAÃÁÄÑÁkÉÁÖÁ.bÁ(J¿#@ðA¤MsAÉjbAËŽæAÖ8>A·ƒ@† ÀÍàwÀõÂãÀï›ÁþrÁt±¿ÈDú@Ïä{@ïñA5j@îæî@mÆ*ÀßâÁVÏÀrÂðA¸êÉBgùB*¬ÐB?×(BDµŒB éQB›â^C\ÎC ÕC÷ÕCòwB®ÝAO §ÁÒÜÁ J)ÁLXÁ a©Á|éÀ÷|ÀÑèvÀÒ(²ÀÚLÐÀþÔ ÁÁ„ÁÆÅÁn×Á!ò›ÁÄ(Á­$ÀŸ¬t@ä‹%A6ÓA6pçA5ÞKAª¢¿åÕèÁjÉÀ¼A­JBGIûB€C Bƒ¾Bƒ’bB6gA¢ðåAøåBD TB]öBb¨B“KB‹qåBI¥dB0¹B,ô¦AøKG@ù4_ÀIϲÁâCÁjÝÁ!UÁYÁiêÁ ¥AqàA†óšAe_Ý?©é‡À‹8Ö?åT–@²û£@À°Û@º“Ú@«&Ç?Ù©ˆÀ| À”ç„À¢³‚À§¬ÁÀž4nÀ§ˆcÀ·ÄJÀµgÀ²' ÀÆ-pÀåŸ_Á :ÔÁq’Á ÁˆÁ´ Á ÀšNA˜nBPB ¨hBËB|,A½Ç¾ö“ÜÀ„sÙ@ŸQôA6ÕA„ŽAˆRA–BtA‡7@º.‚À2Ô ÀaIÒÀ3»Àx?ÀfþmÀC§äÀD®jÀ,(À\YÌÀ$öÀF½À—²öÀJJaAèÂB˜ZûB£ÑæBšëBœô‘ByªÍA"'ÀåbÀ¢•Àcþ|AÚ]Aëª^AáåÁAàIAÞ*A[ÍÀ3XéÀªÛ#ÀPEÀÝüÀœmÀ*ÉÀx]vÀ@dÀW°cAèãBÂÂBÜ¿…BÜ0 BØõRB¸ø¼A»kPÀá´—À¾˜;À¸økÀ„ÕùAUyzBümB;ùB B!~A¹5:>ôãÞÀÊŠ[ÀðuÀÙ»À³ä°A†) B$ÑB¾ËB·÷dB·É™B§š»AÃW£Á`Á&ÌÁ¾jÁ ÁÍç¿ÆWA¤eðAÉëAËĤAÖZA·­þ@†÷=ÀÍLÀõ†lÀî6sÁê°Á<{¿ÇÏž@Ј¥@ïîlAC4@ïC&@nÎpÀ߈êÁT1ÀpÁ9A¸îyBuüB*®¤B?ù÷BDË B îsB›Û)C\‹C ܈CùCó_B®0*APRÁ“ÌÁ 3]ÁøÁ 2DÁGMÀöû¸ÀÐÞçÀÐz ÀØe³ÀýPÒÁì|Á{Á>«Á!û)ÁŠÁ‹µÀŸÒ@äò•A7 €A6¦ÊA5ìqAº®¿ä#ÁìÀ¼dA¬êéBGNB€GPBƒÈBƒ¥´B6ˆvA£æAø'UBDHB]5oBb¸.B“LB‹~BI´áB0ÉçB- ­Aø^¿@ú=’ÀGšTÁj6ÁþÁå¯ÁÐqÁ`€ÁÒ†Aq\A†é\AeVÂ?«[JÀŠí‡?åªU@²Ï@À§y@ºÈO@«U\?Û-ÝÀ{sUÀ”:šÀ¢À§>¸À hÀ¦‰À¶Ð^À´}ƒÀ±DðÀÄŠSÀä?Á |øÀÿ?0Á jÇÁÙ Á:NÁ ÉÀ™"BA˜;€BHB ãBàçB©^A¾"x¾à^kÀƒRÆ@¡ñÝAñâA€VuAˆŽnA–ÁyA‡yx@¼eœÀ1R^À`˜žÀ1²eÀuËaÀf$SÀAÀC—cÀ)¨xÀZ|À"ØÀDt·À—¦ÀIgÅAéœB˜iZB£ã¡BšõBœû Byµ‰A"â,ÀåQ=À¡/FÀbP*AåLAëÆ{AáýíAà:íAÞ.aA[VuÀ1úŽÀª”´ÀœáTÀ¥ŽÀR^ÀÚ‹Àv"rÀ>ÏÀVàøAèí‚B‹BܾbBÜ>UBØú;B¸ùfA»â@ÀákÈÀ¾ CÀ¸ï0À„ ÑAUÊ÷BüUBHüB˜MB$SA¹ G?‚eÀÉüNÀïéÀØÀ³çÇA†P8BB¾ HB·ô…B·ÃýB§›°AÚ†Á[ÍÁárÁ¦¾Áë‰Ás¿DÚA¤~‹Aɵ¤AËú¥AÖ|A·Ù/@‡í ÀÌO:ÀõI§ÀídWÁÖÌÁü¿ÇYh@Ñ-@ð?GAPö@ïŸÅ@o×—Àß/0ÁQÀn¼ÚA¸ò%B„B*°{B@íBDà™B ó£B›ÓñC\KC ä CúJCôJB®BŠAPîùÁToÁ ‚ÁÝ]Á ¬ÁzÀöîÔÀÏÔ)ÀÎÉdÀÖ|.ÀûË£ÁhÁ?GÁMÁ"ÀÁO½Áj'Àžˆ^@åZ¥A7DMA6ÜîA5ú«AÊÇ¿â6 ÁȸÀ¼7ªA¬Ç_BGRB€K˜BƒÒBƒ¹B6‘‹A£-Aø:âBD@B]R BbÈdB“L}B‹Š8BIÄnB0ÚÉB-$ÒAørA@ûHÀEbVÁñ‘Á‘ËÁ©´ÁŒ;ÁVýÁ˜!Apç¿A†ß AeMƒ?¬Î@ÀŠ¡ç?æj@²¢V@Àž@ºüù@«„4?ܳ¹ÀzÉÀ“ŒãÀ¡O¼À¦Ð!À ËÀ¥ˆƒÀµÛQÀ³’ÁÀ°a¯ÀÂå!ÀâÝëÁ¾Àý™ÁŦÁ1ÇÁÀÁ ‰ÝÀ—ôÔA˜hÎBvB ßBöÕBÖÊA¾}ß¾ÊÀ‚0:@¤”èA‘­ÁA€ënA‰CA—AA‡»§@¾ŸUÀ/ÎÉÀ_æXÀ/¦³ÀsT˜ÀeILÀ>‡ðÀBÀ'%–ÀXœÀ ¶ßÀBIKÀ–‹ÃÀH„ AéI‰B˜wÊB£õoBšþ±B“ByÀFA#ž7ÀåÑÀŸÝfÀ`ŸyAðQAëâ½Aâ/Aà\´AÞUÇA[•cÀ0šÇÀªMíÀœqÌÀlùÀÀ‰×Àsä°À;¾êÀV‡AèøBÂà Bܽ=BÜL²BØÿ-B¸ú A¼YÊÀá"àÀ½‘À¸åíÀƒD¶AVÕBü=BVBnB'.A¸ß#? œ‹ÀÉm¡ÀïÐ}ÀØÚÀ³ë A†w®B/B¾ÓB·ñ£B·¾[B§œŸAÃÝÄÁ'Á›»Á ÁÉäÁÆ¿¼wA¤—DAÉÛAÌ0êAÖž.A¸–@ˆäÀË…AÀõ •Àì‘GÁÂÇÀÿ–k¿ÆâY@ÑÓ<@ð„A^°@ïüÌ@pá¢ÀÞÔêÁNºÀlµÕA¸õÍB’?B*²VB@@ BDö9B øßB›ÌµC\ C ë—Cû…Cõ6B®TþAQלÁÃÁ –Á¥ˆÁ ÒàÁÛoÀöáÍÀÎÈ:ÀͼÀÔAÀúD~Á?HÁz)ÁݽÁ" ^ÁÁH{Àõ@åÃTA7}nA7RA6ùAÚì¿àb¥Áw,À¼ øA¬£­BGV0B€OãBƒÜ,BƒÌ•B6š¨A£KGAøNBD@ÀŠö@»fó@«âª?ßÄÀys!À’/ ÀŸèEÀ¥ñKÀ›àÌÀ£„ À³íÓÀ±¹ÇÀ®—÷À¿”Àà7Á=DÀúF‹ÁxäÁàìÀÿ“†Át À••B€‡B,úA¸ˆG?íçÀÈNhÀïžÛÀÖøRÀ³òA†ÇvBœéQB¾-B·ëÚB·³B§žlAÄeRÁ½<Á8Á_ŠÁ†&Á_Ö¿ —A¤ÉAÊ'òAÌž?AÖâÍA¸\@ŠÕ–ÀÉîÀô‘‡ÀêèNÁšYÀþ±Ÿ¿Åñ®@Ó Õ@ñ4Az @ð¸@rø^ÀÞ¹ÁHôÀhŸÖA¸ýB®ÖB*¶B@†¹BE!¨B |B›¾1C[™C úÎCýþC÷B®z AS«×Á”Á×Á5-Á r±Án±ÀöÇ[À̬ÍÀÉ«kÀб0À÷0XÁáÁ í.Á|Á"´ÁžÊÁÅÀœÌ@æ–ŽA7ð¬A7€ÝA6%ÒAû\¿Ü´ÞÁÓÀ»°A¬[ÑBG^B€X…BƒðuBƒóÄB6¬õA£ˆ'Aøv9BD?B]¨žBbù…B“MßB‹¯&BIóyB1 ðB-môAø­@þnøÀ>ªÁ„ÁGéÁóÃÁ½ÆÁ9ÞÁçOAp—KA†¿°Ae0ì?±.UÀ‰½&?ç¤@²ç@ÀV@»œA@¬H?áNyÀxÇtÀ‘~íÀŸ3'À¥ À›JkÀ¢€À²õbÀ°ËÀ­±‚À½éÀÞ®%Á{RÀøšÁÑCÁ7VÀþ››Áè(À”cA˜òB‡B 1þB91B`dA¿’±¾†…À}Œ@¬ÙA“æEA‚¯AŠÊA˜ÃFAˆƒÔ@Å\DÀ+8—À]ÉÀ)t½ÀkÝœÀb²­À6¿À?-üÀ‰]ÀRíÀC[À;¸©À”̨ÀEÒ$AêœB˜£B¤+KB›öBjByà‡A%×ÝÀäUêÀ›Þ]À[7A€ïAì8ZAâ_uAàÂÚAÞÍA\SÍÀ,rÜÀ©w‹À›¦ÀŽÂYÀŒ'DÀŽ”ñÀmîÀ4³oÀS™AéëBÂÄ‹BܹÂBÜx,BÙ5B¸ûßA½Ä ÀàG”À»Õ!À¸É÷À€ã¸AW²BûóB}iBxB/êA¸\?#%ÀǽÝÀï…ËÀÖpÀ³õ×A†ïÇBœÚKB¾7ÍB·èóB·­SB§ŸKAÄ©¢ÁˆÁÈkÁG¿ÁdÁ0¿ùñA¤â"AÊNmAÌÕNA×PA¸ˆ @‹Ð%ÀÉ!ñÀôS‹ÀêdÁ…ðÀþ>a¿Åx@ÓÈÂ@ñ†~A‡«@ñL@tÀÝÂÍÁEóÀfÜA¹¯B½@B*·ûB@ªKBE7yB ÞB›¶éC[bC yCÿÀš³tÀ¡zõÀ±ûÐÀ¯Ü.À¬ÉûÀ¼;ÀÝECÁ¸ZÀöëwÁ(ÍÁŒùÀý¢“Á[œÀ“/TA™ ZB0ƒB MðBO€B޵A¿ïÖ¾_›£À{.²@¯@nA”¥iAƒG3A‹ZÉA™E'AˆÇ@Ç À)­_À]ˆÀ'_ ÀiZhÀaÓõÀ4 ÓÀ>OÀùnÀQEÀÀ9ƒ©À”6zÀDéñAê]B˜²2B¤=dB›%ÙBByëJA&——ÀäfÀš†8ÀYÅA€œAìU,Aâx Aàå,AÞõ.A\“ÒÀ+ ^À©/eÀš­ÀÀމ-À‹ÛÆÀŽBaÀjÒ0À2UÀRÄAé$4BÂÅBܸ”B܆ËBÙHB¸ürA¾>ÀßþJÀ»EˆÀ¸À–À€ÔAWhBûÛBŠBpiB2áA¸0¥?+fÀÇ,²ÀïlÀÕç$À³ùÈA‡bBœË6B¾B“B·æ B·§™B§ $AÄîMÁRÕÁAÁ/ëÁAÐÁ¦¿UúA¤ûRAÊuAÍ ¢A×'ôA¸´K@ŒËæÀÈT_ÀôBÀé;†ÁqfÀýÊ’¿ÄýŸ@Ôqq@ñÙ=A•D@ñtð@u¤ÀÝfUÁBßÀd;A¹HBË¿B*¹äB@ÎBEMZB MB›¯C[.C .CzCøüB®ŸAU„ÁÁ©CÁÃæÁ ¶ÁÀö¬bÀÊŒ ÀÆ8ÀÌÈ€Àô_ÁØHÁ \‹ÁÁ"/*Á'HÁÀ“À›ŸÔ@çlEA8e8A7ïjA6BûA¿ØýÑÁ-•À»TÂA¬SBGg!B€a6B„ëB„CB6¿]A£Å†Aøž[BDSB]âþBc±B“NËB‹ÈBJ&B10uB-ŸMAøÔeAGÀ:#Á‚Ái$ÁxÌÁ2žÁ%øÁpApa)A†ªlAe(?´À‰#?ç³Ç@±¿¡@Àmç@¼‚@¬rK?ägóÀwn¯ÀGÀÆ&À¤žãÀšåÀ t±À±À®ë¦À«ácÀº‹ùÀÛÚ‘Áô\Àõ:»ÁÀÿëÀü¨nÁÎhÀ‘úA™NÓB_¿B jBeçB½?AÀMj¾1ù>ÀxÚè@±ó&A•e_AƒàA‹ì7A™ÇšA‰ Ÿ@Éç[À( =À\ZåÀ%GÀfÔÀ`ôOÀ1~áÀ<ñNÀf;ÀOÀèõÀ7LCÀ“Ÿ¹ÀDŸAê¢çB˜ÀöB¤O‘B›/ÌB"ÜByöA'X=ÀãÖ›À™,ÀX‹A€TAìr"Aâ»Aá¢Aß|A\ÔÀ)¦qÀ¨æèÀš;CÀŽOÛÀ‹ÿÀï[Àh†³À/óóÀQïAé/ªBÂÅ”BÜ·eBÜ•zBÙdB¸üÿA¾¸’Àß´çÀºµ5À¸·-À~‘ýAW»ÕBûÂB—ÛBhEB5ÞA¸‰?3°œÀÆšçÀïS)ÀÕ]ŽÀ³ýäA‡AFBœ¼B¾MgB·ãB·¡ÚB§ ÷AÅ3TÁlÁ9ºÁÁkÁH‡¾ýV;A¥ AÊ›öAÍD8A×JºA¸à¾@È×ÀÇ…æÀóÖ«ÀècµÁ\»ÀýV3¿Ä‚Q@Õà@ò,^A¢Ô@ñÓü@v!ÀÝ PÁ?·ÀbjóA¹ÝBÚSB*»ÐB@ñãBEcLB ÈB›¨MCZüC îCºCùòB®²fAVq‘ÁÑÎÁ’ÁŠëÁ àìÁÉóÀöž³ÀÉzÂÀÄ{mÀÊÐŒÀòƒtÁûèÁ ’ÚÁèÁ"7òÁëÁžLÀ›w@çØA8ŸüA8'A6Q®A,d¿×ÏÁÚUÀ»&YA«î×BGk|B€e”B„8B„/ B6ÈœA£ädAø²˜BDcB^_Bc+gB“OAB‹ÔœBJ#B1AØB-¸&Aøè%AПÀ7ÛFÁTÁøæÁ:ÑÁì”ÁàÁ4 ApEñA†Ÿ¯Ae?µ™9ÀˆÕ”?è Ù@±‘²@Àd@¼=u@¬¢¯?åöûÀvÁ˜ÀiÀÀCÀ¤,úÀ™ƒÀÀŸmFÀ°IÀ­ùöÀª÷¹À¸ÚOÀÚnÁ/YÀó‡ÞÁÕ`ÀþkØÀû­,Á@ŒÀÃA™}‡B:B †CB|eBìAÀ«m¾"íÀv„-@´©A–&&A„yÒAŒ~]AšJ A‰Nl@Ì0×À&‘3À[¢1À#,vÀdJ¯À`½À.ÙªÀ;ÐùÀÏÅÀM(MÀ·¾À5xÀ“eÀC/AêéB˜ÏËB¤aÑB›9ÐB)¥BzÕA(ÏÀã–‹À—Ñ9ÀVI¨A€Aì=Aâ©~Aá*:AßEøA]¬À(>À¨žÀ™È.ÀŽbÀ‹CïÀ›ÞÀf8vÀ-CÀQoAé;LBÂÆBܶ4Bܤ:BÙˆB¸ýˆA¿3¿ÀßkkÀº$(À¸­½À|ôlAX÷Bû©B¥$B`B8âA·Ø=?<ãÀÆ}Àï9™ÀÔÓNÀ´+A‡jtBœ¬àB¾XKB·à0B·œB§¡ÆAÅxµÁçàÁñ×Á+ÁüáÁ ê…¾óò¸A¥. AÊÃAÍ|A×m¢A¹ g@ŽÆøÀƶ‡Àó—ÇÀçŠðÁGîÀüáC¿Ä)@ÕÅ@òßA°]@ò3o@w0sÀÜ«¿Á<{À`TA¹ oBèüB*½ÀBAêBEyNB PB› ùCZÍC ·CúCúëB®ÅOAW`ÁKÁz·ÁQ´Á ¯ïÁ’™ÀöãÀÈg´À¼ÂÀÈÖ0Àðð”Á|Á È?Á¶KÁ"@ÂÁ®ŠÁ{åÀšpH@èDxA8ÛA8^ùA6`tA<Õ¿Õ={Á†½Àº÷˜A«Ê4BGoãB€iöB„B„CB6ÑáA¤cAøÆóBDvB^âBc<2B“O·B‹á7BJ3B1SPB-ÑAøûîAZCÀ5éÁ”ÁˆÁü€Á¦=Á¯Á÷½Ap*ŸA†”àAeÓ?·–Àˆ‡Ã?èd?@±c‘@ÀZ:@¼sž@¬ÓV?燋ÀvÀ޶lÀœUtÀ£º„À˜ëÀždµÀ¯SÀ­Àª þÀ·&ÀØÿ½ÁiPÀñÒßÁ*jÀýxÀú°ÍÁ²ÀŠ¡A™¬wB¾ôB ¢¤B’üBþAÁ ཬ1bÀt*@·aýA–ç¿A…QA@ÀPL@¼©ý@­??é¡ÀufÀŽJÀ››¸À£G€À˜Q³ÀZýÀ® <À¬ À©!2Àµp¼ÀלÁ¢AÀðÀÁ~ŸÀû·‹Àù³RÁ"ÜÀŽP“A™Û£BîîB ¿)B©«BJ4AÁh½j'ÀqÍä@ºA—ª)A…¯™A¤ÔA›RaA‰ÖÔ@Ð˯À#mdÀZ-‘ÀïâÀ_.‹À^OÔÀ)…oÀ9ŒRÀ™ÀIC™ÀMGÀ0—´À‘ØÀA=öAëv´B˜í¨B¤†ŠB›N B7[BzfA)ŸµÀã˜À•öÀRÄÊA€%»AìÉßAâÛEAáoÔAß—|A]–œÀ%iÀ¨ cÀ˜à=À£ÀŠªñÀŒó€Àa“ÀÀ(ÀüÀOh;AéSBÂÇ-BܳÌBÜÁëBÙ'èB¸þŒAÀ+èÀÞØ*À¸ÿâÀ¸šÅÀy³AX¹^BûwB¿ÓBO‡B>þA·?LʃÀÄáËÀïøÀÓ¼ÑÀ´ =A‡½ªBœŽOB¾n=B·ÚOB·yB§£RAÆ‹Á|\Á`úÁ ÐLÁ·YÁ -%¾áTA¥a=AË®AÍì“A׳ØA¹gZ@ÆÍÀÅÀóÀåÖŒÁñÀûõ´¿Ã N@×±@ó(AËU@òó‹@yQÍÀÛîöÁ5ÉÀ\1A¹†BŒB*ÁªBA^mBE¥ƒB $†B›’ECZuC )iC|CüâB®ë\AY@)Á [ÁKêÁÞ—Á M]Á#?ÀötÝÀÆ>À¿9jÀÄÚAÀíÄöÁ`~Á 0JÁRBÁ"RyÁ4Á6¼À™=w@é(A9R>A8ÏŠA6~?A]Ý¿ÑsÞÁÞˆÀº™A«€sBGxÖB€rÅB„._B„k-B6ä€A¤A¿AøïÿBCþªB^YLBc^B“P¢B‹úšBJSFB1vB.fAù#¡AonÀ0ôPÁ™>Á¤ÂÁ~ÞÁ¥ÁýÁ~RAoó®A† Adóí?ºéÀ‡ë1?é @±¸@ÀFN@¼à“@­5k?ê­?Àt·ÀM[ÀšáÀ¢ÓïÀ—·ÊÀœPÀ­ À«ùÀ¨4TÀ³¸ÕÀÖªÁÚ-ÀîbÁÑþÀú[Àø´¹Á“ÀðAš B'B ÛÓBÀrBy£AÁÈ;ÒñÀonV@¼Ý_A˜mdA†K¬AŽ9#A›×AŠo@Ó À!ØŸÀYq¥ÀÍáÀ\›ÑÀ]l|À&ÖkÀ8hÀøÏÀGM™À À.V¹À‘>øÀ@P,Aë¾B˜ü¯B¤™B›X?B>FBz!1A*d ÀâÔµÀ“µúÀPþÏA€+žAìçfAâôHAá’ÖAßÀƒA]×ýÀ#üuÀ§Á‡À˜kaÀiÀŠ^ÀŒžŸÀ_=GÀ&UfÀNŽ™Aé_Àx^AY¢Bû^BÍ9BG,BBA·R.?U;ÛÀÄM‚ÀîëçÀÓ0”À´A‡ç³Bœ~ïB¾yLB·×\B·Š¢B§¤AÆJÿÁFfÁÁ ¸QÁ”\Á ÍǾ×usA¥{AË9LAÎ%9A××&A¹”¤@‘È€ÀÄCÀòÙGÀäúìÁÁÀû¿ÂŒ›@×È"@ó|¨AØÄ@óT4@zcÍÀÛ¿Á2RÀYÿMA¹ BsB*äBA‚èBE»¶B *3B›ŠåCZMC 1QC¾CýáB®þ€AZ1©ÁÉíÁ4jÁ¤±Á ÇÁë?Àöf§ÀÅ'jÀ½t½ÀÂØ­Àì,9ÁìÁbñÁôÁ"[aÁ÷ÁùÀ˜¢Ô@énA9ŽQA94A6BAnt¿Ï‹”Á‰ëÀºiEA«[WBG}bB€w2B„8ØB„YB6íÙA¤aAù±BCýÊB^w3BcoB“QBŒbBJcwB1ˆ9B.¸Aù7‰AúõÀ.¢Á´Á2<Á?ŒÁÑdÁò‡ÁA4AoØA†tAdéD?»àÀ‡œp?éom@°Ø@ÀÄBE5A·%?]¶ãÀøšÀîѬÀÒ£­À´üAˆBœoB¾„jB·ÔgB·„ÅB§¤ÈAÆ‘ÎÁKÁΩÁ  MÁq9Á mõ¾ÍÚÇA¥”æAËaAÎ^"A×ú–A¹Â#@’ËdÀÃp Àò™,ÀäYÁóoÀûã¿Â @ØuU@óÑ­Aæ,@óµD@{v°ÀÛ/ûÁ.ÈÀWÝÃA¹B$oB*Å¡BA§‹BEÑúB /îB›ƒCZ'C 9DCCþâB¯·A[$%Á‡1ÁÛÁjÁ éÿÁ³ÀöXPÀÄœÀ»®ÀÀÔ²ÀꑆÁžNÁ”­ÁísÁ"dRÁ¹XÁñÀ˜_@éüTA9ʸA9AA6œYA¿Í ùÁ4öÀº9%A«6BGúB€{£B„C]B„“™B6÷:A¤€šAùBCüîB^•;Bc€4B“QBŒ9BJs¸B1šB.6(AùK|A‡À,M7Á›’Á¿%ÁÿåÁ‰ÕÁçòÁÐAo¼WA†hîAdÞv?½ À‡M_?éÉ'@°©@À2%@½Nd@­˜‡?íÙÀsYÀ‹áÀ™hûÀ¡ë#À–‚4Àš6ïÀ« /À©03À¦WeÀ°BÊÀÓ4VÁFôÀêé™Áv<À÷zÀö´3ÁqiÀŠ˜ïAšjŒB€WB –BîHBÙ-Aˆ=È.ßÀj¦i@ÂeKA™öOA‡†/AcìAœâMAŠ¥t@×ǦÀ©ZÀWö—À‚mÀWm À[£À!n–À6^À ®…ÀCZNÀ™€À)Í•À &À>q=AìMñB™ðB¤¾-B›lÜBL>Bz6ËA+ïyÀâRÀñPÀMk¿A€7ƒAí"àAã&AáÙAAàA^[À!äÀ§,ÉÀ—äÀŒôÑÀ‰ÃOÀ‹óxÀZˆÀ!vUÀLØDAéxBÂÈÔBܰ BÜîòBÙ7·B¸ÿïAÁ¤±ÀÝú‘À·DÀ¸~ÀtÄ4AYºNBû+Bè$B6NBH[A¶÷×?f;œÀÃ#Àî·GÀÒÀ´Aˆ<¡Bœ`B¾–B·ÑoB·~âB§¥{AÆØøÁÚ Á„öÁ ˆBÁMðÁ ¯¾Ä2QA¥®çAˉAΗNAØ(A¹ïØ@“ÏyÀœ)ÀòXÃÀã@ÒÁÝüÀú"¿ÁŒ¨@Ù#H@ô'Aó‹@ô¼@|ŠvÀÚÏ«Á+)ÀU¹‘A¹B3€B*Ç¢BAÌUBEèNB 5µB›|CZC AAC ECÿäB¯%A\žÁD&Á;Á03Á ¸Áz–ÀöI×ÀÂöžÀ¹åbÀ¾ÎOÀèôàÁ»£ÁÅÁºÁÁ"mJÁ{FÁÎÀ—k@êkØA:sA9zIA6«…Aȿ˴ ÁߪÀº¬A«¤BG†ŸB€€B„MìB„§ìB7¡A¤ 7Aù.nBCüB^³dBc‘jB“RBŒ!BJ„ B1«éB.O¶Aù_xAçÀ)õ»ÁÚÁK{Á¿éÁAøÁÝEÁÆ&Ao „A†]ÄAdÓ„?¾gÀ†ýý?ê#5@°yø@À'ù@½…ž@­Êy?ïqEÀr©(À‹)¿À˜«ŽÀ¡uèÀ•æ‡À™(œÀª“À¨7•À¥gSÀ®„¦ÀѼôÀþ÷œÀé)õÁÇÀö<[Àõ²DÁßÀ‰X‘Ašš§B±NB 2®BVB HAÂè¢>%DÀh> @Å-ôAš»ÿAˆ$ AúdAhÀAŠêÞ@Ú äÀÚÀW7tÀXûÀTÑÀZ¼éÀµÄÀ4óÀ{ÀA]ÀX8À'…lÀpaÀ=€Aì–sB™**B¤ÐßB›wDBSKBzAšA,¶’ÀâgÀŒ ÀKžªA€=…Aí@ÔAã?ÕAáü¬Aà<°A^ÂÀ­÷À¦áæÀ— BÀŒºuÀ‰u†À‹3ÀX)aÀÚÀKû‘A鄽BÂÉdBÜ®âBÜþBÙ= B¹[AÂ#€Àݰ‚À¶®¡À¸t{ÀsHAZ´BûBõ¨B-ÊBK‡A¶Êb?nÊÀÂŒëÀÀчâÀ´jAˆg†BœPwB¾šÑB·ÎvB·xúB§¦(AÇ }Á£¬Á:æÁ p/Á*€Á ¬õ¾º|A¥ÉA˱KAÎпAØAÛAºÃ@”Ô¾ÀÁÇcÀò ÀâbXÁÈhÀúÑ¿Á h@ÙÑû@ô|ÙA â@ôxœ@}ŸÀÚnÎÁ'xÀS’¸A¹ ‰BB¦B*ɧBAñEBEþ³B ;‰B›t­CYâC IHC ŠCéB¯8aA] ÁÍÁí‹ÁõœÁ …ÕÁAîÀö;<ÀÁÜpÀ¸´À¼Å„ÀçVDÁ×ëÁõgÁ‡ÝÁ"vKÁ<åÁªõÀ–Î@êÛüA:DA9³´A6ºÄA …¿ÉÄÍÁŠÀ¹×ÜAªëBG‹OB€„B„X‡B„¼SB7 A¤¿óAùCxBCûAB^ѯBc¢µB“RyBŒ.BJ”kB1½âB.iaAùs€A¡RÀ'›ŸÁ›ŠÁ×@Á˜ÁùÍÁÒÁˆ7Ao„˜A†RˆAdÈn?ÀøÀ†®L?ê}—@°J©@À½@½½@­ü­?ñ ÀqøÄÀŠq›À—í5À¡ À•JDÀ˜$À©ÖÀ§=ÏÀ¤v0À¬ÄmÀÐCÂÀý_GÀçh/Á%ÀôÙ¯Àô¯9ÁM)ÀˆžAšÊýBâ„B OëB}B 9AÃI°>BgÀeÒ¹@ÇùÁA›‚€AˆÃÛA‘•AïÆA‹0@Ü|ÂÀrqÀVw?À-ÀR1ÝÀYÕßÀù®À3ÉlÀW-À?]GÀCÀ%:ÝÀŽÕ À<ÖAìßWB™9uB¤ã¤B›¼BZdBzLkA-~–ÀáÎkÀŽ&`ÀIÏ8A€C“Aí^ìAãY/Aâ 9AàfrA^à:À;œÀ¦–¬À–’ÀŒóÀ‰'tÀ‹FwÀUÇìÀŒ¼ÀKÙAé‘–BÂÉöBÜ­£BÝ IBÙBjB¹ÃA¢éÀÝfZÀ¶€À¸jÕÀqpwAZg|Bú÷B7B%8BNºA¶œ»?wbÀÁö%ÀîüÀÐøþÀ´$áAˆ’´Bœ@ÜB¾¦B·ËzB·s B§¦ÐAÇh^Ám'ÁðyÁ XÁëÁ KǾ°¸A¥ãBAËÙ¬AÏ sAØe±AºKã@•Û4ÀÀñ·Àñ×Àá‚ëÁ²²Àùžï¿À‰O@Úp@ôÓA 0@ôÚâ@~´¨ÀÚ dÁ#²ÀQi9A¹$BQàB*˯BB]BF(B AjB›m=CYÃC QYC ÏCðB¯KÓA^ƒÁ½&ÁÕÊÁºÊÁ StÁ Àö,€ÀÀÁÀ¶NÀººQÀåµ´Á ó'Á$eÁTÈÁ"SÁþ5Á‡·À–0@ëL¿A:äA9í`A6ÊA±O¿ÇÓ<Á4 À¹¦³AªÅPBG B€‰ B„c-B„ÐÎB7„A¤ßÐAùXŸBCúqB^ðBc´B“RîBŒ;BJ¤ÝB1ÏðB.ƒ+Aù‡‘A/_À%>äÁ£ÁbsÁ>ðÁ±UÁÇ ÁJAoh’A†G9Ad½4?Á•¼À†^J?êØO@°'@Àr@½ôµ@®/#?ò¦CÀqGèÀ‰¸ªÀ—-ïÀ ‰ÊÀ”­jÀ—„À§ýøÀ¦BâÀ£ƒûÀ«!ÀÎÈÁÀûÄåÀå¤HÀþÌ´ÀóuwÀó«Áº À†ÓAšûBúB mMB3¼B j*Aë.>qÜ®Àcdw@ÊȰAœIÓA‰càA‘)Ažw]A‹v€@ÞÛAÀÔÀUµ÷Àþ§ÀOÀXíèÀ:TÀ2žtÀ¦œÀ=[ÀÍ À"íéÀŽ9À;šuAí(œB™HÐB¤ö{B›ŒDBa‡BzW=A.G‡ÀáŒ)ÀŒ¾ŽÀGýgA€IªAí}(AãržAâCéAàaA_"øÀÇÔÀ¦KÀ–7ÀŒEKÀˆÙÀŠïDÀSc¸ÀýÀJ?Aéž›BÂÊŠBܬbBÝBÙGÐB¹'AÃ"îÀÝÀµ¦À¸a(ÀoÃÂAZ¾¤BúÞBÏB˜BQôA¶nâ?€ôÀÁ^¾ÀîgÀÐiqÀ´*…Aˆ¾+Bœ12B¾±sB·È}B·mB§§sAǰšÁ6~Á¥¯Á ?ðÁã/Á ê%¾¦æ3A¥ýAÌ=AÏDjA؉¨Aºz9@–âÚÀÀ$Àñ•¶ÀࢉÁœÜÀù%}¿À]@Û1¥@õ)ˆA w@õ=@ËÀÙ«nÁÙÀO=A¹'tBa/B*ͺBB;›BF+­B GWB›eÉCY§C YtC CùB¯_YA^÷ðÁy0Á½ùÁ½Á ßÁÏøÀö¢À¿¤…À´VÀ¸¬¶Àä0Á VÁRyÁ!€Á"ˆdÁ¿6ÁdYÀ•‘^@ë¾!A:¿šA:'MA6Ù€AÂ%¿ÅßYÁݺÀ¹u3AªŸjBG”ÕB€ŒB„mßB„å]B7A¤ÿÌAùmäBCù¥B_¨BcÅŒB“SdBŒH-BJµ_B1âB.Aù›­A¾ À"߈Àÿ2KÁíÁýôÁhŽÁ¼©Á ‡AoLsA†;ÙAd±Ö?óÀ† ù?ë3[@¯ër@À @¾,“@®aÛ?ôC Àp–“ÀˆþìÀ–m½À çÀ”ùÀ•ö¾À¦÷øÀ¥FÌÀ¢¶À©=ÀÀÍKïÀú(xÀãÞ@ÀýisÀò²Àò¥ËÁ&JÀ…üA›,]BE¯B ŠÓBKB šñAÄ >Ã"À`óE@ÍšÁA÷AŠ®A‘Â!Ažÿ‡A‹¼¸@á<`À3äÀTóÀÍÆÀLêBÀXÀwµÀ1r(¿ÿåÀ;V…¿ÿŸÀ žÀœ¢À:¥÷AírDB™X¨±ãÀ^"@ÐoõAÚìAЦGA’[{AŸˆCAŒ5@ã À‘ÀÀT01À šiÀJAÌÀW5À±ÒÀ0Dˆ¿úwaÀ9O~¿úp£ÀLÑÀŒÿ‘À9°ZAí¼MB™g¹B¥dB›¡‡BoðBzlæA/Ü,ÀáÓÀ‰ê7ÀDR®A€UúAíº A㥾A⋲AàäÌA_©DÀÛúÀ¥²ïÀ•(ÏÀ‹ÏŠÀˆ;†ÀŠ?zÀN“À™ÀH~Aé¹,BÂ˵BÜ©ÙBÝ;GBÙRµB¹ßAÄ$ÈÀ܇PÀ´QÄÀ¸M·ÀldªA[nBú©B,B 0BX{A¶?ˆ²FÀÀ.Àî0ÍÀÏHXÀ´6NA‰õBœ±B¾ÈPB·Â|B·aB§¨§AÈB%ÁÈÃÁÁ ’Á›EÁ %…¾“+A¦2¬AÌSòAϹ$AØÑýAº×†@˜õ¹À¾kJÀñ)ÀÞÞìÁpÊÀø0鿾ýì@Ü”Q@õ׺A 5ë@ö"@€ýKÀØåÜÁëÀJÜÐA¹.PB€ B*ÑÜBB†BFXéB SWB›VÕCYvC iÊC¤CB¯† A`ç½ÁðZÁŽ%ÁóÁ»Á]"ÀõÿÀ½gÙÀ°ÛõÀ´ŠIÀàÈIÁ >ŽÁ«âÁº]Á"šŸÁ@JÁ@À”Qt@ì¢ÂA;<A:›èA6øŒAã÷¿ÁðÁ0À¹*AªS%BGž‹B€–—B„ƒdB…¶B70 A¥@#Aù˜ÅBCøB_L'Bcè¸B“TNBŒbBJÖ•B2™B.Ñ>AùÄAÝKÀòÀý(ÊÁ ÁzûÁÖÁ¦oÁ ÀAoæA†$áAdš¬?Æ(;À…le?ëês@¯‹r@¿ô3@¾œó@®È?÷7Ào2€À‡‰À”ê”ÀŸ#wÀ’ÓSÀ“Ï¿À¤è•À£K*À ¦öÀ¥®ÃÀÊLÛÀöé}ÀàKËÀúðÀï?‚Àð—ëÀÿù•À‚ÿ A›Ž¬B©×B ÆNBz B ý+AÄÒC>Àº™À\@ÓHLAž¤³A‹HªA’õA ’AŒI÷@æÀí³ÀSk²À d’ÀG–;ÀV0xÀèªÀ/“¿õ«À7F¿õÓMÀø®ÀŒaîÀ8¹žAî¸B™wGB¥/tB›¬ABw5Bzw½A0§àÀàÿÀˆ}²ÀByÅA€\2AíØµAã¿nAâ¯ËAáGA_ìÒÀcèÀ¥fVÀ”¯8À‹”pÀ‡ìNÀ‰æãÀL&¡À™ôÀGœÁA鯶BÂÌMBܨ’BÝJ½BÙX4B¹4AĦÀÜ<ÆÀ³¸¼À¸CóÀj²HA[ÆbBúB9ÕBgB[ÉAµä0?³À¿”ÏÀîhÀζÍÀ´À¼G¼À¯DÀ²uwÀßæÁ U˜Á×7Á†Á"£ÈÁ^Áù…À“°D@íA;z²A:Ö–A70Aôô¿¿õÄÁØ·À¸Þ¢Aª,ÅBG£yB€›"B„Ž7B…#€B79œA¥`~Aù®bBC÷YB_kBcúnB“TÄBŒoÂBJçHB2ýB.ë€AùØ=AmÜÀ±·Àü"DÁ‰‹Á8þÁŒgÁ›-Á NtAn÷yA†JAdŽá?ǰÌÀ…#?ìF}@¯[&@¿éª@¾Õt@®û‘?ù"—ÀnÁÀ†ÌáÀ”'žÀžªêÀ’4À’º…À£ß2À¢KžÀŸ°|À£ä&ÀÈÊ™ÀõFîÀÞ_Àù5¯ÀíÕÀïOÀþÎÀµ3A›À-BÜJB äCB‘©B!.AÅ5}>ØÝEÀYŽ @Ö#ÅAŸoKA‹ë×A“XA ›sAŒþ@èoÀG½ÀR¦!À ,AÀDçÀUDÏÀ>À-åJ¿ï‡nÀ5:#¿ñ0›À¢%À‹Ã¹À7ÁÅAîQ„B™†æB¥B˜B›· B~…Bz‚–A1t€Àà€eÀ‡œÀ@ž~A€buAí÷‚AãÙ3AâÔAá9ðA`0§ÀêiÀ¥fÀ”5 À‹Y1À‡œÍÀ‰ÖÀI·qÀ®ÀF¹îAéÔmBÂÌçBܧHBÝZCBÙ]»B¹„AÅ)ÀÛò#À³ûÀ¸:(ÀhþA\ BúuBG•Bù‘B_Aµµ’?‘uøÀ¾úëÀíùÙÀÎ$˜À´BÅA‰näB›ñóB¾ßgB·¼tB·U B§©ÆAÈÕÁZyÁ véÁ ßÁRÂÁ _¾~)ôA¦h2A̦hAÐ.íAÙÙA»5ª@› YÀ¼·×ÀðfÀÝÁD4À÷:¿½ò@Ýú@ö‡pA P>@öÌR@‚ÐÀØÁ¯ÀFqòA¹5BŸ;B*Ö BBÒBF†gB _ŠB›GÒCYNC zHC5C0B¯®4AbÛ|ÁfIÁ^Á‘>ÁT‘ÀÿÒÛÀõàÙÀ»&nÀ­0“À°^=ÀÝuÁ k”Á£ÁRsÁ"¬úÁÀ"ÁÕ«À“D@í‰àA;¹·A;…A7èAü¿½ø™ÁÀ¸«ÂAª>BG¨sB€Ÿ±B„™B…8]B7C3A¥€øAùÄBCöB_Š*Bd :B“U9BŒ}BJø B2+vB/áAùìAÿÀGÜÀû‘ÁäÁ ö«ÁBhÁÒÁ ãAnÚóA† ¡Ad‚ò?É:‘À„É‘?ì¢Ý@¯*¨@¿ß@¿,@¯/R?úÅ~ÀmÌŠÀ†íÀ“cºÀž1ÐÀ‘”SÀ‘¤%À¢Ô­À¡JéÀž¸ñÀ¢tÀÇF‡Àó¢TÀܰÒÀ÷ËÃÀìi Àî…—Àý¡VÀ€iÈA›ñêBýB \B©`B!`JAÅ™'>ñçÀW@Ù`A :µAŒÎA”+ÛA¡%æAŒØJ@êÛÀŸÞÀQß~ÀñtÀB5ÊÀTX9À LÀ,³­¿êªÀ3+пìˆÀI7À‹$ðÀ6ÈÎAB™––B¥UÏB›ÁèB…àBzpA2B Àà<ÄÀ…ŸôÀ>ÀÚA€hÂAîsAãóAâøfAádÈA`tÁÀo{À¤ÌÀ“ºCÀ‹ËÀ‡MÀ‰4QÀGE‚À ÅÀEÖAéâQBÂÍ‚BÜ¥ýBÝiÚBÙcKB¹ÐAŬÀÛ§hÀ²„À¸0TÀgGÔA\xBú[BU`Bð¬BbyAµ†Â?•ßÀ¾`gÀíÞÀÍ‘¹À´IBA‰›ÉB›áþB¾ë B·¹lB·N÷B§ªMAÉ!Á#Á *OÁ ÆÉÁ.HÁû0¾iüeA¦ƒ!AÌÏìAÐj7AÙ?zA»e @œóÀ»ÜÃÀðJÀÜ2^Á-·Àö½Ð¿½jä@Þ­ù@ößÜA ][@÷1@‚¤=À×¹bÁ sÀD8‰A¹8~B®òB*Ø(BBøBF?B e·B›@JCY=C ‚–CCCB¯ÂAcÖÕÁ ÌÁEîÁU Á þÀÿ^€ÀõÑSÀºñÀ«WáÀ®D›ÀÛÉDÁ€„Á+$Á3Á"¶4Á—Á±²À’kq@íþ]A;ùA;LµA7'µA¿»ùÁ)À¸xŠA©ßŽBG­yB€¤DB„£ÿB…MOB7LÐA¥¡“AùÙôBCõåB_©^BdB“U®BŒŠqBKàB2>B/ _AúÐAâÀÛbÀú¯Á™¬Á ´ÁøÁ„^Á Ï An¾SA†æAdvÞ?ÊňÀ„w®?ìÿ‘@®ùø@¿Ôh@¿G@¯cU?üiíÀmÚÀ…R,À’žëÀ¸)ÀóñÀŒžÀ¡ÉÀ I ÀÀUÀ H¯ÀÅÀ¦Àñû¯ÀÚà$Àö`-ÀêûœÀízÂÀüs?À~9’Aœ#ãBAîB šBÁ/B!’/AÅýA?¸?ÀT‘/@ÛäA¡ðA4A”ÈA¡°ëAÚ@íI_ÀöÀQÈÀ´.À?€éÀSj·Ày˜À+€»¿ä}`À1¿çÛ(ÀíäÀŠ…•À5θAîèBB™¦VB¥iB›ÌÔBGBz˜KA3„ÀßøÝÀ„.»À<à×A€oAî5ˆAä ÿAãèAáÎA`¹!Àó À¤~~À“>åÀŠâ?À†üïÀˆÚVÀDÐÔÀ ;ÀDñ6AéðaBÂÎBܤ¯BÝy‚BÙhãB¹AÆ/ÀÀÛ\”À±éJÀ¸&zÀeÄA\цBú@Bc4BçºBeÛAµWÁ?šM À½ÅDÀíÂ:ÀÌþ1À´OêA‰ÈøB›ÑúB¾ö¹B·¶cB·HßB§ªÏAÉiÁë¢Á ÝXÁ ®vÁ §Á–Ö¾U³AA¦ž/AÌù¡AÐ¥ÄAÙd=A»”¤@)½À»ÊÀðkÀÛLGÁÀö@ü¿¼âÙ@ßb²@÷8©A jq@÷–@ƒ2À×T!Á$ÀAüxA¹;ÛB¾¾B*ÚHBCEBF´'B kðB›8¾CY/C ŠïCÊC YB¯ÖAdÓ+ÁÚÿÁ-ºÁžÁí8ÀþéµÀõÁ«À¸àDÀ©}.À¬(‘ÀÚÁ”hÀþ§uÁéÂÁ"¿vÁ>¾Á›À‘ÇÎ@îszA<8½A;ˆ%A77•A(4¿¹÷NÀÿ¡GÀ¸DûA©¸¶BG²‹B€¨ÚB„®ôB…bTB7VuA¥ÂMAùïèBCõ0B_ȳBd0B“V$BŒ—ßBKÄB2P§B/:üAú)A #WÀlGÀùŸÁ áÁ qÁ­‚ÁxÑÁ ŽîAn¡™A…öAdj¦?ÌQ³À„%|?í\›@®É@¿É°@¿€A@¯—š?þãÀld²À„“žÀ‘Ù/À=óÀRùÀsðÀ ¼@ÀŸF ÀœÆ§ÀžwÕÀÄ8ôÀðRþÀÙ TÀôòìÀ錋ÀìnÐÀûCØÀ{œkAœVBu B >üBÙB!ÄMAÆaÊ?ð…ÀRY@ÞÈÿA¡ÓýAÚA•e A¢<ƒAg¯@ïº@ÀJeÀPOÀtlÀ<ÈíÀR|HÀ£_À*Lu¿ÞîÀ/Ý¿ã(fÀ,À‰å¦À4Ó…Aï44B™¶'B¥|uB›×ÐB”¹Bz£(A3ßèÀß´°À‚»ñÀ:þwA€u}AîTÁAä'AãAAá»A`ýÆÀuXÀ¤0‡À’ÂïÀЦŽÀ†¬’ÀˆäÀBYfÀ}ÀD RAéþBÂξBÜ£`B݉:BÙnƒB¹YAÆ´ÀÛ¨À±M\À¸—ÀcÕÏA]+TBú%BqBÞ»BiCAµ(?ž¿ØÀ½)Àí¦+ÀÌiÿÀ´V¾A‰öoB›ÁçB¿xB·³XB·BÁB§«LAÉ´<Á´Á Á –ÁäàÁ2 ¾AN‰A¦¹ZAÍ#†AÐá•AÙ‰"A»Är@ž9·Àº#éÀïÃúÀÚe=ÁYÀõØ¿¼Yõ@à,@÷‘×A w}@÷û¡@ƒÀiÀÖîSÁÁÀ?½ÁA¹?4BΟB*ÜkBCD”BFË B r6B›1.CY$C “RCC pB¯ê&AeÐ|Á”åÁwÁÛöÁ¹?ÀþtzÀõ±áÀ·»fÀ§ {Àª ÀØjÏÁ§?ÀüöÎÁµÁ"ÈÀÁý•ÁidÀ‘#X@îé5AÀŠ.¹À† ûÀ‡ÉœÀ=bOÀ^ÑÀBÀ¸guÀï<-ÀØ”NÁÒvÀôÇ¿»E¡@á…a@øEUA ‘~@øÇÛ@„Þ[ÀÖ!Áù¿À;8]A¹EÛBîžB*à½BC‘§BFùBB ~èB›"CYC ¤7C¯C ¤B°AgÎÁÅÁä¾ÁaõÁPµÀýˆ·Àõ‘éÀµnÀ£áÀ¥ÆÀÕ‡ÁÉÇÀùÁKEÁ"ÛlÁzVÁ šÀ×ù@ïÖŠA<ùºA<;øA7g°A[濳ã÷ÀýŠûÀ·¨@¿©*@À,ø@°5÷@…xÀjEdÀ‚S$À‚qÀ›ÌÀŽl‡ÀŒ#À#Àœ6À™Ó5À˜øÏÀ¿–þÀëL§ÀÓˆÀð¡(Àå6 ÀéDNÀ÷­ÄÀs²AœîB/B ›B!\B"\AÇ‘ÿ?5ç:ÀJt0@çŠqA¤@ AÏwA—@8A£â·AŽ@Ì@÷¥À ;ÜÀMî8¿÷LÀ4ŽYÀO«p¿ú0À&§©¿ÎòÀ(¿²¿ÔïþÀ h¤ÀˆkÀ1Û5AðSB™æB¥¶ýB›ù*B«RBzÃÈA6S›ÀÞæ„À|´UÀ5I%A€ˆåAî³FAäušAã°NAâ=¸AaÍYÀ ókÀ£D’À‘KƒÀ‰ò–À…¹ÂÀ‡mÆÀ:â¥ÀË¿ÀAS…Aê*]BÂТBÜŸeBݸÅBÙ•B¹AÈDhÀÚ0PÀ¯u5À·þÂÀ^œ•A^;BùÕBšêBÃiBs¦A´™Î?¬5QÀ»R|ÀíPþÀÊ©nÀ´l>AŠ€ŽB›‘UB¿& B·ª*B·0DB§¬ AÊ–‘Á HÁ ¥ßÁ LÛÁu¦Áè¾zåA§ AÍ¢XAÑ–žAÙøœA¼U@¡pËÀ·‡áÀî÷ÓÀתiÁ»SÀôH ¿ºº1@â=@øŸ¦A žr@ù.’@…mþÀÕ¹œÁõ!À8ñ±A¹I)Bþ½B*âëBC¸lBGlB …TB›gCYC ¬¸CüC ÁB°&ÉAhÎZÁ À¿ÁÌIÁ$œÁ#Àý.ÀõºÀ´E¯À¡þ^À£ [ÀÓNuÁÙxÀ÷ÙáÁ Á"äÏÁ8@ÁüÀ1@ðN#A=:¶ABD^B ¹öB9£B"AÇøE?BSkÀGå—@ê{ÜA¥^Ax*A—à A¤p˜Aމ´@ù˜Àˆ‡ÀM!'¿ò¹7À1ÉòÀN¹N¿ôS™À%n¿ÈrÀ&¢Æ¿Ð'ÐÀ WÀ‡`1À0Û‰AðgÌB™öB¥Ê¦BœiB²ðBzΫA7&®ÀÞ¡?ÀyÂ7À3]NA€sAîÓAäöAãÕAâi¦AbÀ oëÀ¢õ<ÀÍ/À‰¶LÀ…h?À‡yÀ8`<¿ülÀ@i‹Aê9KBÂÑGBÜžBÝÈ¿BÙ…WB¹3AÈËÀÙåÀ®Ö`À·ôÂÀ\ÛA^–RBù¹B¨ñBº2Bw)A´iÖ?°»€Àº´;Àí4DÀÊ”À´s¿AН+B›B¿2B·§B·*B§­AÊâºÁÔÁ WÁ 4aÁPGÁšK½ÝOµA§'2AÍÍAÑÓ}AÚA¼…À@¢…ˆÀ¶§gÀî³*ÀÖ¿Á¤ÀóÈe¿º-ç@âõš@øúWA «^@ù•²@…þÀÕQœÁðoÀ6¨^A¹LtB ñB*åBCßWBG'¦B ‹ÌB›ÈCY C µDCKCàB°;&AiÏœÁ ykÁ³ÄÁçÁç_Àü›6ÀõqjÀ³À ©À¡xJÀÑ–mÁèÀö!éÁà£Á"î:ÁõÛÁ×TÀމT@ðÆ[A=|A<µA7ˆ&A~›¿¯ËyÀü#_À·>A¨ô BGÌB€ÀB„ægB…Ì–B7‡A¦gÊAú_gBCñèB`gOBd‹ B“XmBŒÛèBKo/B2¯B/ÁÎAú{A ÀfÀóÞÁ¼^Á Á3îÁ=Á JGAnuA…ºAd+p?Ô ŠÀ‚…Î?ï2Á@­Ñ²@¿“.@À¡/@° Õ@2OÀhØÖÀ€ÎÐÀîªÀšÒ›À%JÀ‰çJÀ›kjÀš%¢À—Ö>À•DfÀ¼wKÀçèßÀÏÏSÀí·§ÀâIùÀç"gÀõC&Àn[QATBxÌB ÙBRB"ÂBAÈ^ú?N̘ÀET @ípjA¥áA‘!§A˜€›A¤ÿ AŽÒá@ü ÀÓIÀLS¿î êÀ/qÀMÆA¿î†zÀ$3'¿Â“À$ƒk¿ËZHÀ—¥À†½eÀ/Ú¿Aðµ¦Bš:B¥ÞaBœ¸BºšBzÙA7ú­ÀÞ[³ÀvÌöÀ1oA€– AîòÿAäªhAãúÒAâ•ÃAbYÀ êþÀ¢¥ÀNEÀ‰yÝÀ…sÀ†´¶À5Û¿÷;mÀ?~‹AêHfBÂÑíBÜœ´BÝØÊBÙ‹ B¹]AÉR^ÀÙ™šÀ®6ÐÀ·ê¹À[¢A^òBùžB·B°îBz³A´9¬?µF†Àº[Àí`ÀÉ{À´{lAŠÞB›p¨B¿>B·¤B·#ÓB§­gAË/=Á›ÆÁ õÁ ÞÁ*ÁÁ3:½³rxA§BóAÍ÷×AÒ AÚC–A¼¶š@£›uÀµÆÀîn4ÀÕÓÄÁŒ©ÀóH0¿¹ Ä@ã®×@ùUiA ¸B@ùý8@†Ž—ÀÔéÁëªÀ4\dA¹OºB :B*çRBDiBG>ñB ’RB› $CYC ½ÚCšCB°O—AjÑÚÁ 1ÈÁ›/Á©:Á²gÀü#ÏÀõ`øÀ±ñEÀž2óÀŸMÑÀÏÜrÁõ´ÀôhÁ«Á"÷­Á³'Á²ƒÀàÇ@ñ?2A=½©A<òA7˜A ¿­»¿Àûn‹À·fA¨ÌUBGÑùB€Ä°B„ñ B…âB7ßA¦‰CAúv BCñLB`‡kBd—B“XâBŒé±BK€uB2Â>B/Ý AúA ŸNÀšŒÀò²zÁ@(Á ØÁç€Á1{Á ˆAmó A…­ÊAd_?Õ³èÀ‚1»?ï‘Ç@­Ÿ¡@¿ˆ@ÀÛœ@°Ö¨@ àÀh!ÙÀ€ rÀ#dÀšUÀŒ€ÊÀˆÇµÀšWÛÀ™°À–Ö(À“gÀºä¹Àæ3êÀÍï¼Àì@fÀàÑÀæÈÀô àÀk«:Aˆ7B­yB øOBjzB"õ¸AÈÆ?[R¿ÀB¿‘@ðhA¦³wA‘ËîA™!áA¥ŽAS@þ–­À#ÀKƒÌ¿éƒ¨À,7ÔÀLÒF¿è²ÒÀ"ö翽 ™À"a¡¿Æ‡dÀ+ŽÀ†À.Ø×AñâBšpB¥ò0BœBÂOBzäuA8ϘÀÞáÀsÔ“À/~ˆA€œ­AïAäÄðAä IAâÂAbŸ_À d¢À¢UŠÀÎÃÀ‰=HÀ„Ä^À†W{À3S-¿ò~À>’†AêW­BÂÒ•BÜ›YBÝèåBÙòB¹ƒAÉÚBÀÙNÀ­–‡À·à©ÀYRRA_NBùƒBÅB§›B~DA´ P?¹ÖdÀ¹uÛÀìúQÀÈâåÀ´ƒEA‹ @B›`%A§zÎAÎNAÒ‹²AÚA½î@¥ÊâÀ´’Àíã_ÀÓùRÁ]yÀòF¿¸ƒó@å#”@ú ¯A Ññ@úÍ|@‡°ôÀÔNÁáãÀ/¼{A¹VAëA=lºA7¹nA³ ¿©•VÀúØÀ¶œ A¨|HBGÜÔB€ÎB…3B† EB7¤ŽA¦Ì’Aú£­BCð B`ÈBdÂÃB“YÌBpBK£2B2èÆB0Aú¹aA Í«À”úÀðŒ¨Á FÁ MÁM»ÁíÁ „8Am¸*A…•AdÐ?ØÞ?Àˆ¥?ðPÑ@­:æ@¿q¿@ÁQ@±C@»MÀf²wÀ}žÀ‹ŠÀ™X]À‹6À†…À˜-ZÀ—TÀ”ÒÈÀ¦1À·º&ÀâÃÞÀÊ**ÀéLäÀÝÜ=Àãç5Àñ™cÀfA“Að B’B7;B›±B#]QAÉ•µ?t…þÀ=É@ö`âA¨YÕA“"ÛAšf–A¦­ÒA°AÏêÀ¨ÀIâ'¿à:CÀ&™KÀJç‹¿Ü÷æÀ zj¿±À¿¼ÑŒ¿þ˜_À„ÑÀ,ѬAñ¡Bš7B¦Bœ2 BÑÛBzúFA:|2À݉kÀmÚeÀ+–JA€ªAïS£Aäú@AäkŸAã0Ac,ÀÀS£À¡´xÀŽÍøÀˆÃ«À„WÀ…›£À.;"¿ç‰ÖÀ<·lAêvÀBÂÓêBܘœBÞ MBÙœ¯B¹ÁAÊëÚÀضÑÀ¬SÇÀ·ÌsÀUÂA`]BùLBápB”ÎB…zA³¨?éÀ¸4ýÀì¿´ÀǰŽÀ´“yA‹lyB›?5B¿bB·šµB·þB§®jAÌìÁñùÁ _Á Ò'Á¹KÁûN¼Ò?)A§–èAÎy‚AÒÉ AÚµ A½Ji@¦äbÀ³}Àí€ÀÓ «ÁE¯ÀñÄ.¿·ôD@åß@úhäA Þ¼@û69@ˆBÍÀÓ¬ÁÜãÀ-hŒA¹YxB PB*îBD|‰BG…4B ¦-Bšô!CYC ×ÙC CrB°_AmÞ}Á Y ÁQ ÁînÁOÀúºûÀõ.ØÀ®i¾À˜rÎÀ˜¿÷ÀÊ¢ÃÀþ0aÀï/¿Á Á#6Áé1ÁCUÀ‹â7@ò­rA>„ŠA=ªoA7ÊAÄž¿§~¦ÀùKøÀ¶eyA¨TBGâUB€ÒÍB…B†"üB7®pA¦îiAúº©BCïB`è‰BdÕzB“ZABfBK´ªB2ü*B0/ÈAúÎAeË¿üƒÀïwúÁ ÈÁ ÁdÁ Á A§Amš‰A…ˆ­AcöR?Úu8À3¡?ð°Ö@­>@¿f{@ÁŒ*@±y¬@•(ÀeúÀ{yÀм À˜Ù,ÀŠÀÀ…bÀ—hÀ•öëÀ“Ï~À¡À¶"$ÀáÇÀÈD0ÀçУÀÜ_;ÀâÑ@Àð^,ÀcˆAž$nBLýBVéB´pB#‘sAÉþ(?€™‹À:ð{@ùaúA©.?A“Ï€A› A§>ŽAúGA,¿ýÖpÀIº¿ÛŽ À#Å^ÀIð˿פÀ:-¿«Ã„Àí­¿·î˜¿ù±ÑÀ„,xÀ+ÌiAñðáBšGwB¦. Bœ=œBÙ²B{0A;SáÀÝBÆÀjØ›À)žŸA€°ÖAït"AåAä‘AãHAcsÙÀÈþÀ¡clÀŽL¯Àˆ†¤ÀƒÌfÀ…=À+ªþ¿âDÀ;ÈWAꆌBÂÔ–BÜ—:BÞšBÙ¢šB¹ØAËuÀØkÀ«±QÀ·ÂLÀS÷A`d‘Bù0Bï¨B‹RB‰A³w?Ç£À·“ŸÀì¢&ÀÇdÀ´›ÔA‹œ„B›.œB¿nÂB·—˜B· «B§®µAÌdÝÁ¹Á ÇÉÁ ¹…Á“-Á’l»^”A§³ AÎ¥AÓÑAÚÛ#A½|@§ÿÀ²7ƒÀíWSÀÒÁ-ÅÀñA·¿·c»@æ›S@úÅyA ë@ûŸ]@ˆÕÀÓA\Á×ÎÀ+öA¹\¯B a,B*ðIBD¤7BGœÀB ¬åBšìmCY'C à˜C!ßC›B°¢Anä¬Á .Á85Á¯´ÁÜŒÀúAÖÀõßÀ­:1À–„À–‹ßÀÈàõÀüC,Àín¢ÁÒªÁ#ÊÁ¥@ÁÀ‹6d@ó(ÅA>Ç}A=èeA7Ú®AÖ?¿¥e¤Àø”jÀ¶.zA¨+šBGçáB€×‰B…óB†8ÇB7¸YA§`AúÑÃBCïBa +BdèEB“ZµB!kBKÆ1B3£B0K‘AúâÕAþŒ¿÷ ÑÀîbÁ I›Á ÀÇÁ ²¾ÁÿüÁ þÑAm|ÎA…|*Acè°?Ü cÀ€ÞN?ñ/@¬Õc@¿[(@ÁÇr@±°‡@oÈÀeA2ÀyëìÀ‰íÀ˜YoÀ‰èåÀ„=ßÀ•þTÀ”èZÀ’Ë#À‹ÜþÀ´ˆRÀßK¥ÀÆ\ÀæR¸ÀÚà¬Àáº.Àï!¦À`ËLAžXøB‚¨BvºBÍGB#ÅÎAÊg ?†ö”À8P=@üf4AªzA”|ïA›®,A§ÏÝADÌAY¾¿úXÛÀH<9¿ÖÝ À îVÀHù¿Ñ"ØÀøœ¿¥óoÀÂ(¿³H¿ôÆzÀƒ†ÍÀ*ÆAò@£BšWñB¦B(BœI>Bá”B{A<,{ÀÜûÜÀgÓ®À'¤–A€·¤Aï”ÅAå/æAä·Aãu Ac»8À<ìÀ¡ÀÊÏÀˆIwÀƒy+À„ÝïÀ)¿ÜùÀ:Ø&›A7ëlAçì¿£JQÀ÷Ü,Àµ÷#A¨BGízB€ÜIB…*dB†N¥B7ÂHA§2wAúèúBCî{Ba)îBdû'B“[*B/BK×ÉB3#2B0gyAú÷žA—î¿ññàÀíKÁ Ê‹Á zÁ dËÁó^Á »µAm^ùA…o•AcÚé?ݦÂÀ€ˆª?ñqÝ@¬¢U@¿OÄ@Âð@±ç¤@K+Àd‡ÛÀx],À‰.À—Ù#À‰AtÀƒ‰À”åÀ“Ø¡À‘ŶÀ‰õFÀ²ì°ÀÝŒwÀÄq×ÀäÓ"ÀÙ`Àà¡ÿÀíãÐÀ^ lAž½B¸’B–±Bæ7B#úcAÊÐZ?ZÀ5­@ÿm‘AªÙ†A•+(AœS A¨a¾A–A ¡¿ö×sÀGg§¿Ò&üÀ4ÀH…¿Ë.ƒÀµ·¿ ÓÀ”5¿®ž¿ïÖWÀ‚àÀ)¾‰AòÈBšh{B¦VUBœTñBéB{ A=ÀÜ´«ÀdËŸÀ%¨/A€¾|A﵌AåJÙAäݧAã¢?AdÜÀ¯lÀ ÀMÀHXÀˆ $Àƒ%¦À„~cÀ&‚y¿×¨ÞÀ9çAꦪBÂÕôBÜ”qBÞ:fBÙ®‰B¹úAÌŠÉÀ×Ó+Àªj7À·­èÀP[\Aa BøøB 8Bx2B}A³¢?ÐîeÀ¶OÀìf‰ÀÅàÀ´­ A‹ývB› eA7ü>Aù¥¿¡,«À÷#AÀµ¿tA§ÚJBGóB€á B…5áB†d—B7Ì?A§T­AûNBCí÷BaJÒBeB“[ŸB=¢BKéqB36ÖB0ƒAû rA1ò¿ìÔ°Àì2ÛÁ JéÁ 3 Á ‰Áæ¨Á xTAmA A…bíAcÌÿ?ßATÀ€2·?ñÒà@¬o@¿DR@Â>¥@²@ 'RÀcÎ ÀvÌÑÀˆL^À—XJÀˆ™kÀò À“ÊÉÀ’ÇÀÀ¿8Àˆ zÀ±O?ÀÛË>ÀÂ…xÀãQáÀ×ÞçÀ߈´À줩À[HdAžÂ¾Bî»B¶ÌBÿ>B$/1AË:?“ÄÀ3îA<A«°dA•Ú,Aœø¤A¨ô1AÚ¥AèÓ¿óR:ÀF’¿ÍkúÀ6öÀGÿ¿Å3¥Àq}¿š?±ÀcÓ¿©%™¿êákÀ‚9ÀÀ(µìAòáNBšyB¦j–Bœ`µBñyB{%ùA=àtÀÜm4ÀaÀmÀ#©kA€Å_AïÖxAåeâAåïAãÏ AdJÇÀ ~À n9ÀŒÅIÀ‡Î«À‚ÑÙÀ„`À#ê¿ÒSZÀ8ôõAê¶ûBÂÖ¦BÜ“ BÞJäBÙ´ŒB¹AÍOÀׇÀ©Å“À·£ªÀNбAa~tBøÜBŽBnB”6A²ã?Õ›TÀµ«ÆÀìH{ÀÅCìÀ´µéAŒ.\BšüuB¿“âB·Ž4B¶÷ŽB§¯vAÍPÓÁ ¢ÁÓÙÁ onÁíÁU=oE`A¨zAÏ)AÓÃüAÛN1A¾l@«VEÀ¯ƒ,Àì‚ûÀÏFÁå<Àï¶ñ¿µ­ @èÔ—@ûÝ~A –@üÝ6@ŠŽÀÑýÒÁÈÀ#þJA¹f?B “|B*÷'BE+BGãÈB ÁYBšÕ;CYSC ûC%ÛC#B°àÑAqý Á 3ÃÁíMÁò'Á:ÀøÓÊÀôê+À©¤kÀ«ëÀá'ÀÃÏÀön÷Àè PÁ.ZÁ#:¶ÁוÁ­fÀ‰.@ôžzA?’KA>£ÊA8 $A l¿Ÿ ´Àöi¦Àµ‡nA§±eBGøÐB€åÓB…AhB†zB7Ö»ÒÀÜ%wÀ^²À!¨IA€ÌLAï÷ˆAåAå*[Aãý1Ad’ö¿ý DÀ ÏÀŒA¢À‡‘ À‚}ÂÀƒ½çÀ!Nø¿Ìø‘À8ÊAêÇyBÂ×XBÜ‘ŸBÞ[sBÙº˜B¹AÍ¢oÀ×:ëÀ© 6À·™eÀL¸!AaÝ+BøÀB(ïBdÚB—öA²±h?ÚMÀµêÀì*BÀħÀ´¾òAŒ_ŒBšë B¿ _B·‹B¶ñ#B§¯«AÍ 1Àÿ¨fÁÏÁ V¬Áù6Áê`=£95A¨%*AÏUjAÔâÂA8A>¿œêkÀõ¯]ÀµOA§ˆYBGþB€êžB…LûB†·B7à@A§™yAû/OBCìûBaŒÿBe4JB“\ˆBZBL óB3^_B0»äAû68AgÝ¿âŠÀéþàÁ IðÁ ¤"Á yÁÌðÁð¿AmßA…IhAc°½?âzÀ ½?ò•ä@¬þ@¿-=@¶²@²Žˆ@ áëÀbYÀs§KÀ†§ùÀ–TîÀ‡G—ÀC@À‘’¹À¢ˆÀޝÀ„1¥À®ëÀØBªÀ¾¦XÀàJ`ÀÔÖñÀÝRÆÀê"mÀU¸ÜAŸ-tB[ÌB÷qB1–B$™yAÌé? « À-±ÝAK;A­`”A—:‘AžEýAªÍA‘q’A })¿ìÀ~]õ?ò÷å@«Ô&@¿!œ@Âó @²Æ®@ À\ÀaÈÀr!À…ÔdÀ•ÒlÀ†ËÀ|ï_ÀuÀŽ0À¥VÀ‚AÀ¬l ÀÖ{OÀ¼³•ÀÞÄ ÀÓP¢ÀÜ6%ÀèßWÀRì\AŸc(B’´BúBJåB$ÎóAÌy÷?§)À+ëAÕ/A®9æA—ëòAží¾Aª®÷A‘½oA ÉL¿è«¡ÀD ¥¿¿4ÀŒžÀDῳ×ÀœÕ¿ˆ"ÀÄ¿š,h¿ÛåçÀ€AßÀ%•`AóÕ+Bš«LB¦§ÉBœ„cBž ¦B{FÏA@uRÀÛ•+ÀXŒ ÀžìA€ÚHAð:Aå·~AåwšAäXÜAe$'¿öÖDÀŸuòÀ‹8À‡\ÀÔ¸À‚ûÀ{¿Â36À6cAêèúBÂØÃBÜŽÆBÞ|ÃBÙÆÉB¹Aμ‚ÀÖ¢JÀ§ÓNÀ·„ÄÀI SAb›½Bø‡BEÏBQLBŸŠA²Mi?ã¿2À³¾SÀëíQÀÃk{À´Ñ‡AŒÂÇBšÉÈB¿¹†B·„¿B¶äBš½äCY•C èC)ÞC¾B± 4AurÁ T—Á¡ÓÁ2ˆÁ•ËÀ÷aÒÀôµGÀ¦öÀŠÁ»À‰ ÈÀ¾-Àð‡ÞÀâÁˆÁˆKÁ#WëÁ"Á;®À‡A@öÇA@` A?atA8@OAA ¿˜žãÀô8¿À´ÝKA§5ÆBH ,B€ô@B…dCB†½&B7ô\A§ÞÃAû^ÅBCìBaϱBeZÍB“]qBvÆBL0¶B3†=B0ôÂAû`'A N¿Ø+pÀçÆ-Á F®Á ÏÁ ÚyÁ²ÕÁhAlÈNA…/šAc“ë?å·À}¯?óZ;@« @¿ë@Ã/™@²ÿ@ Ÿ’À`âÀp{\À„ÿãÀ•O\À…óhÀz™1ÀV$ÀŽx±ÀŒš’À€O€ÀªÇXÀÔ±èÀº¾²ÀÝ<5ÀÑÈÇÀÛfÀçšñÀP³AŸ™BÉÚB8¨BdMB%¦AÌåt?­­À(QA`´A¯ A˜žAŸ–7A«C³A’ ’A ¿¿å ÀC0¶¿ºN\À¢õÀC©¿­ÖÀSJ¿‚‰åÀ ‰÷¿•#ø¿ÖÝÑÀ1ˆÀ$ˆJAô'9Bš¼+B¦¼VBœiBžËB{QÄAAStÀÛL›ÀUtMÀ–°A€áUAð[AåÒÝAåžoA䆸Aem(¿ó¬úÀŸ"€Àг"À†×KÀÅÀ‚™²Àm¿¼È¢À5"'AêùýBÂÙzBÜVBÞƒBÙÌîB¹úAÏJtÀÖUÔÀ§+ÃÀ·zhÀG5Abû–BøjBTMBGpB£]A²?è‚À³˜ÀëΙÀÂÌ­À´ÛAŒôÒBš¸ÆB¿Æ/B·”B¶Ý¿B§°+AÎoÀþN#Á‰†Á 7Á„-Á§•>£ÜA¨{êAÏÛ¢AÔÂ’AÛésA¾ÝÉ@¯Û2À«ÛsÀëc›ÀËs5Á‚µÀí ¯¿³X:@ëÖ&@ýX&A Cì@þŠ©@Œá€ÀÐF¿Á²Ài™A¹rËB ×´B+BE¾)ÝqA¨™AÐÀAÕáAܘA¿'@°ÿgÀªïEÀëÀÊ{ÿÁiÀÀí¶¿²Àæ@ì˜k@ý·ÂA Pm@þ÷@wTÀÏךÁ¬fÀýËA¹uåB èöB+ÝBEç"BH[tB älBš®ACYÍC 'ÿC,ŽC/B±JØAw9•Á ¾GÁo/Á±£Á'IÀöiÀô‘]À£“ À†ÆCÀ„”ÀºŒÀìúÀß#ÝÁžÁ#kÁzŸÁïCÀ…ºU@÷ÁA@êÚA?á)A8bÑAe¿”JÀò¿gÀ´j&A¦â“BHüB€ýðB…{·B†éäB8“A¨$ŒAûްBCë3BbçBe¥B“^ZB“³BLTºB3®qB1.AûŠ?AÛC¿Í·SÀåˆÂÁA%Á‚&Á :Á˜VÁÞRAl‹UA…ƒAcv‡?èùõÀ|PÛ?ôæ@«7r@¾þZ@é[@³p­@`HÀ_iFÀmIÀƒTÀ”G”À„œÞÀuåîÀ ÀŒJ:ÀŠØÀxÊÀ§x„ÀÑùÀ¶ÎˆÀÚ'_ÀδkÀØÙ’Àå5ÀJsêA ¬B8æBzsB—dB%p¹Aͽ¼?ºÈ‚À"äpA |qA°ÊÅAšÒA éSA¬nãA’¢¥Aµ–¿Ýâ§ÀAy¢¿°¡ÎÀ ÆTÀAr¿ É9À¼7¿m«Àq¿‹¿Ì¿FÀ|‰ªÀ"jÅAôÌxBšÞB¦å¨Bœ¨¦Bž"7B{g³AC{ÀÚº©ÀO;nÀ!A€ï‘AðžõAæ ÜAåì€AäãºAeÿû¿íQÔÀžz–À‰¦À†Z¸À€ÕÀÔ“À(¿±ã°À32ŸAë‰BÂÚîBÜŠqBÞ¯6BÙÙQB¹ÙAÐh(ÀÕ¼ŸÀ¥ÚÀ·e™ÀC~ìAc¼lBø1BqiB3B«A±µ÷?ò©À±ËCÀë¨ÀÁÀ´î«AYÄBš–”B¿ß­B·{7B¶ÐµB§°eAÏ2aÀýeéÁâ0Á ÚkÁ5gÁÎ>@2šA¨¶VAÐ6AÕCsAÜ7ßA¿Dº@²$ÍÀª0ÀêÒÀɃÔÁPªÀì’-¿²(º@í[q@þ¿A \å@ÿcÏ@Ž ™ÀÏgêÁ¦¡ÀVA¹xúB úMB+@BF/BHs”B ë–Bš¦jCYìC 1C-èCkB±`GAxH Á r©ÁUÅÁpØÁï¼ÀõëðÀô5À¢XÑÀ„ņÀ‚JÂÀ¸¸·ÀêâÀÝRJÁà}Á#ujÁ3çÁÈßÀ…$@÷š¬AA0¿A@!dA8t0Aw¿’0ÀòµÀ´0A¦¸¼BH÷BÎB…‡‚B‡`B8¹A¨G Aû¦ÒBCêËBb4µBe•1B“^ÎB¢@BLfÔB3«B1JñAûŸZAy¯¿ÈueÀähGÁ½…Á8ÒÁ ê:ÁŠñÁ™All²A…\AcgŸ?êœïÀ{ ’?ôƒ:@«Ñ@¾ò{@ÃæŽ@³©Û@AÈÀ^¬*Àk­mÀ‚|ÖÀ“ÂÛÀƒð·ÀsˆÙÀ‹òÌÀ‹1DÀ‰sàÀtÙbÀ¥ÎcÀÏIqÀ´ÓAÀØštÀÍ'êÀ׸}ÀãÅßÀGšÉA V£WA¨Ó¸AÐcAÕ„IAÜ_HA¿x‚@³KcÀ©5ÀêˆäÀÈŠ·Á7rÀì ¿±³@î8@þxA iV@ÿÐý@ޤOÀÎ÷¬Á ÇÀ;A¹| B! ¸B+¥BF9cBH‹ÅB òÍBšžŽCZC :?C/BC ©B±uÊAyX¨Á &½ÁB›MB§FBœÁ&Bž2ÏB{}¨ADÕ2ÀÚ'ŸÀHöÀ^A€ý÷AðâëAæA1Aæ;AåA6Af“å¿æë@ÀÑMÀˆ—ƒÀ…ÝŒÀ€)À ™ÀÄ5¿¦é°À1?Aë?ÆBÂÜiB܇ƒBÞÑ+BÙåÕB¹¥AшIÀÕ#À¤†WÀ·P¬À?Á1Ad~ÅB÷÷BެBxB²ðA±P ?û±1À°{qÀëR ÀÀJÒÀµòA¿ÜBšt'B¿ùgB·tÓB¶Ã’B§°ˆAÏÕÀÀü|’Á9gÁ ¨€Áæ Àÿå²>m/©A¨ñ8AБ?AÕÅcA܆ÓA¿¬@´s)À¨%SÀê?aÀÇ¥ÁÀëi¿°õÔ@îã¿@þØÛA u¾AI@;wÀΆâÁšÚÀªxA¹B!8B+ BFb½BH¤B úBš–¯CZ2C CnC0C!éB±‹aAzi¬ÁÚƒÁ"¿Á î’Á€Àôð‚ÀôZÀŸàÉÀ€¾ À{`Àµ Àæ‡hÀÙ©¥Áo¦Á#‰<Á¥ŠÁ{»ÀƒžN@øž`AA½„A@¢œA8—*A›d¿¹uÀð„DÀ³ºÜA¦d—BH(B ”B…Ÿ;B‡-•B8'A¨Ž'Aû×mBCêBbx³Be¼‰B“_·B¿‡BL‹:B3ë_B1„üAûɯA¸l¿½áÉÀâ#ÇÁ´‘Á¥(Á H‹ÁoÞÁ ¤Al/A„íØAcIb?íæzÀz>?õJá@ª˜ø@¾Ú@Äa˜@´ÿ@À]0ˆÀhqsÀ€Ë„À’·ÀÀ‚–¦ÀnÇÆÀ‰ªëÀˆûßÀ‡T½ÀlëƒÀ¢t¯Àˤ=À°ÖOÀÕ{žÀÊ BÀÕrýÀá1DÀAßA ªIBáSBÞ5Bä»B&‚AÏl?΢PÀ«A1ÏA³cAœ$ÍA¢ëcA®3òA“ŠFA­²¿Ò÷LÀ>Þú¿¡ùÉÀäÀ>±¿Ž;ËÀÏ¢¿H§™ÀBé¿wR࿽mˆÀx…CÀ6AõÇ4B›B§$1BœÍBž;-B{ˆ¥AE·ïÀÙݱÀEΞÀJ A:AñAæ\üAæb¡Aåp:AfÞC¿ã³­À|%Àˆ!À…ž¾À¥qÀ€©iÀ ¿¡dÊÀ0C©AëQ§BÂÝ(B܆ BÞâ>BÙì#B¹„AÒAÀÔÖÀ£Û,À·F*À=ß|AdàƒB÷ÚB]BWB¶æA±È@DÝÀ¯Ò™Àë2€À¿¨³Àµ WAóUBšbÙBÀYB·qžB¶¼øB§°’AÐ'øÀü}ÁäwÁ ~Á¾!Àÿ >ëÇA©ÖAпAÖÀAÜ®€A¿àµ@µœ!À§5‹ÀéõÀÆ• ÁŸÀêø.¿°[@ï©@ÿ9úA ‚AVG@ÓÀÎŒÁ”ÙÀ4A¹‚%B!.ÎB+ {BFŒ?BH¼XB`BšŽËCZYC L¨C1øC#*B±¡ A{{¬ÁúÁ #Á ­ÁGáÀôr#ÀôGôÀž¢ýÀ}n™Àv¾,À³2ÅÀäÀ×Ò”Á6ðÁ#“2Á]åÁTúÀ‚è¨@ù!)ABdA@ã™A8¨ÅA­œ¿‹„œÀïĆÀ³¿A¦:HBH./B}B…«(B‡DMB81TA¨±šAûïçBCé«BbšåBeÐUB“`+BÎABL†B3ÿÙB1¢/AûÞéAX¼¿¸ÀàÿÂÁ/;ÁZÓÁ ÷>Áb/ÁljAl/A„à{Ac: ?ï Ày‹ö?õ¯4@ªcÀ@¾Î@ÄŸn@´Vô@êàÀ\rÀfÑÀâòÀ’1_Àè»ÀlcÉÀˆ…HÀ‡ßqÀ†C’ÀhîXÀ ÅÀÉΓÀ®Ô¤ÀÓé³ÀÈyÀÔN‘ÀßäþÀ>üvA á BöBÿÀBþ³B&KAÏs…?ÕM:ÀçøAƼA´B AœÛµA£˜/A®ÌA“ØA¿ÏKÞÀ=þ¿ 3¿ûÏŸÀ=í¿‡ÿ•À~¿À&¦À‡†'À…_ÉÀ~øÀ€DÃÀ _G¿›Ú À/GLAëcµBÂÝéBÜ„ŽBÞóbBÙòzB¹^AÒªÕÀÔ‰À£/GÀ·; À;ûãAeB¡B÷½B¬B )BºâA°éU@³À¯)!ÀëÈÀ¿êÀµçAŽ'BšQ}BÀZB·ngB¶¶XB§°–AÐzŒÀû’ Á*Á vuÁ–Àþ+‡>M…A©,’AÐí1AÖHaAÜÖOAÀ@¶ÆHÀ¦DÜÀé«rÀÅ™¨ÁëÀênd¿¯¿‰@ðo@ÿ›zA ŽvAy@kÀÍ£¨ÁŽÅÀ ºþA¹…,B!@xB+ëBFµèBHÔ»B¼Bš†äCZ‚C UìC3UC$nB±¶ÉA|ލÁA"ÁïwÁ kaÁˆÀóóUÀô5EÀdÀy]ÀroÀ±W‹ÀâxˆÀÕù¯ÁþÁ#0ÁðÁ.À‚22@ù¤ABK˜AA$ÖA8ºtA¿á¿‰MrÀïÀ³DIA¦ÐBH4ZBjB…· B‡[B8;•A¨Õ-Aü~BCéSBb½7Beä6B“`ŸBÝ BL¯áB4iB1¿Aûô-Aù­¿³9/ÀßÚÁ©TÁ)Á ¥¤ÁTgÁ(Akñ%A„Ó Ac*”?ñ4ÓÀxÙ,?öÜ@ª.U@¾Âa@ÄÝ|@´‘+@ÏoÀ[³Àe/À~-À‘ªoÀ::ÀiýÀ‡^„À†ÁÜÀ…1UÀdíÀŸ¼ÀÇöÝÀ¬ÐØÀÒVÀÆæhÀÓ) ÀÞ—iÀ<´A¡2BRØB!oBÃB&‚ÑAÏâ ?Ûþ¢À!€A]:Aµ!êA“gA¤E²A¯dØA”& AY«¿ËœŸÀ=.¿˜§¿õÐÖÀ<=¿¼ÖÀ +D¿0 ô¿ù^¿b¥á¿³ÀuÑíÀ gAöpEB›4B§NABœæbBžL B{ž£AG€-ÀÙIÀ?vgÀ ÒAàAñIëAæ”ÒAæ²AåÎÌAgsÏ¿Ý;ôÀœÐÎÀ†ü•À… ®À~J1À¿MÀ¨±¿–K3À.IêAëuïBÂÞ¬B܃Bß—BÙøÙB¹4AÓ=ÀÔ;íÀ¢‚¨À·1À:fAe¥!B÷ŸBºÝBíB¾åA°µ±@$©À® ÀêòæÀ¾bxÀµ"£AŽ[$Bš@BÀ jB·k.B¶¯²B§°•AÐÍ{Àû|Á9Á ]cÁmÞÀýM>˜½ A©JkAÑrAÖŠEAÜþ@AÀI½@·ñ¡À¥SGÀéaÀÄœ¼ÁÑHÀéä ¿¯#@ñ5Ú@ÿý[A šÅAÄß@‘•ÀÍ19ÁˆÀ ?GA¹ˆ/B!R6B+^BFß·BHí-B&Bš~øCZ­C _:C4²C%´B±ÌšA}¢¡ÁóýÁÕ»Á )pÁÖüÀótÀô"uÀœ#ÕÀuGœÀmkâÀ¯z]ÀàmòÀÔöÁÄïÁ#§5ÁÍ­ÁÀzé@ú(—AB“AAfTA8Ì8AÒ2¿‡õÀîBþÀ³|A¥å0BH:’B…Ã$B‡qøB8EÝA¨øßAü!2BCèÿBbß«Beø-B“aBëãBLÂNB4)B1ÜîAü |A›@¿­ÝÀÞ´.Á"ÛÁÅ)Á S»ÁF†Á:‚AkÒA„ÅŠAc÷?òÝÍÀx%Â?öxØ@©ø¸@¾¶3@Å¿@´Ë¥@´ÂÀZó‹Àc‹vÀ|u<À‘"òÀ€‹"Àg”èÀ†6ŸÀ…£À„À`ç‡À`ŠÀÆÀªÊëÀÐÀÝÀÅR(ÀÒdÀÝH„À9-ËA¡QB‹úBCCB2ëB&ºOAÐQ?ⶇÀXAõIA¶™AžKâA¤óïA¯þ'A”tRA± ¿ÇéŽÀ<:¬¿“%%¿ïËÙÀ;  ¿vçÀ ׿#Ê¿ôÂø¿X?Q¿­ð­Àtv‰À÷aAöÅ`B›E{B§ceBœòìBžT‡B{©¤AHe®ÀØþAÀ¤:^A©hcAÑIäAÖÌmAÝ&RAÀ~’@¹*À¤`ËÀéLÀÞÜÁ·jÀéY¿®…Ø@ñýdA/ÏA § Aüy@‘œÀ̾<Á‚aÀÀéA¹‹/B!d B+ÕBG ®BI°BœBšw CZÛC h’C6C&üB±âA~·•Á¦‰Á»ïÁ çDÁž=ÀòôkÀôƒÀšâyÀq.Àh»†À­›:ÀÞaCÀÒBhÁ‹¤Á#±CÁ…Á ßþÀ€ÂÏ@ú­=ABÚûAA¨A8ÞAä¿„Ø'Àí4À²ÌVA¥ºhBH@ÕB OB…Ï2B‡ˆëB8P,A©±Aü:BCè¯Bc@Bf 9B“aˆBúÊBLÔÊB4=ÈB1ú{AüÕA=t¿¨{–ÀÝŒŸÁ›ÐÁyÔÁ …Á8Áó–Ak²ÅA„·öAc 6?ô‡úÀwq·?öÞ*@©Âè@¾©ö@ÅZ:@µ`@šØÀZ3›ÀaæBÀz»›ÀšèÀ¶æÀe*À… ™À„ƒ9Àƒ §À\ÝâÀ›«‰ÀÄAOÀ¨ÂÝÀÏ)òÀü[ÀÐÚ¢ÀÛøNÀ6A¹A¡‰ BÅ[Be;BM+B&òAÐÀl?étéÀ‹½AŽéA¶äAŸ(A¥¢ãA°˜A”ÂàA ä¿Ä2«À;W¿Ž)¯¿éÀ¥À:¿jGxÀ ”¿f¿ð"ô¿MÎ ¿¨½zÀsÀà¯ÅzA©†xAÑx‡A×ÙAÝN‡AÀ³@ºKäÀ£miÀèËDÀ  ÁkÀèÍ¢¿­ç¹@òůAa A ³LA4F@’5ßÀÌJ³Á|À?ãA¹Ž*B!uòB+PBG3ËBIDBBšoC[ C qôC7nC(FB±øxAÍ…ÁXÆÁ¢Á ¤ÞÁeJÀòtOÀóüpÀ™ŸíÀmšÀdZÀ«º"ÀÜR{ÀÐdÁR'Á#»ZÁ<9Á ¸ÁÀ€ ä@û2‚AC#*AAêA8ïûAöú¿‚šÀì¾»À²ÙA¥wBHG%B%GB…ÛLB‡ŸñB8ZA©@£AüRòBCècBc$öBf ZB“aüBŽ ÁBLçWB4R˜B2&Aü47AàI¿£ëÀÜcâÁ3Á.)Á¯Á*zÁ¬eAk“nA„ªPAbûP?ö3YÀv½ ?÷CÐ@©Œç@¾ª@Řë@µA^@²ÀYs3À`?sÀy"ÀOÀ~V[Àb¼ÒÀƒãrÀƒb,Àô7ÀXÐÀ™ô·ÀÂcwÀ¦¸­ÀÍ‘]ÀÂ%ÀϱÃÀÚ¦ÉÀ3RA¡ÁPBþûB‡XBgƒB')öAÑ0B?ð9ÉÀ ¼sA*A·ÆkAŸ¿8A¦RA±2zA•³Aey¿ÀwöÀ:rr¿‰)C¿ã¯<À9 ¿]šÄÀ *¾¿ õ¿ë~¿CR¿£…}Àq¼QÀÇùA÷p»B›hxB§çB 3Bže§B{¿«AJ3sÀØgìÀ5Ú’ÀÂ?A**Añ²1Aæé5Aç*=Aæ^AhV-¿ÓrðÀ›Í;À…\UÀ„b{À|=À}[¿üèë¿…}UÀ+K¢Aë­¨BÂàýBÜ~ŠBß8—BÚ 'B¹˜AÔ÷3ÀÓSôÀ xqÀ·.À4Z’AfÎãB÷FBçhBáæBËA°œ@ ††À¬}Àê’?À¼t%ÀµCÚAŽøÿBš wBÀGñB·awB¶›B§°qAÑÈlÀù¹çÁ6XÁ ÿÁ ô\Àú¬R>»^`A©¤«Aѧ[A×QˆAÝvÝAÀèÝ@»zÎÀ¢y ÀèïÀÁ BÁƒJÀèA–¿­HÂ@óŽ»A’¢A ¿ƒAlG@’Ï®ÀËÖžÁu®À¼7A¹‘"B!‡ïB+ÎBG^BI6èB&­BšgC[>C {aC8ÎC)’B²„A€r9Á µÁˆ$Á b=Á,%ÀñóÄÀóé;À˜\1ÀhïÀ_L^À©×ÀÚAšÀ΃ÐÁyÁ#ÅxÁó Á ‘fÀ~ N@û¸fACk­AB,RA9ûA r¿€Y•Àëû”À²SA¥d^BHMB*CB…çrB‡· B8dÞA©dµAükþBCèBcGÎBf4‘B“bpBŽÆBLùôB4g}B25ïAüI¥Aƒ¿¿¨ÿÀÛ9÷ÁŒÁâ)Á\.ÁOÁdíAksýA„œ˜AbëF?÷ßíÀvÂ?÷©Ë@©V²@¾‘N@Å×Ó@µ|ž@iPÀX²RÀ^— ÀwBÑÀ‰)À|ô£À`MSÀ‚¸)À‚?øÀ€Ý´ÀT¾À˜<ÀÀƒ“À¤¬\ÀË÷ÀÀŒÀ·ÈÀÙSôÀ0`A¡ùÑB8ÛB©šBóB'bAÑ ˆ?÷&À ê8AÆÞA¸©A zA§õA±ÍA•`ÊAÁ_¿¼¹oÀ9Œ¹¿„#â¿Ý—žÀ7ù=¿PàÿÀÒ”¾üî¿æÔT¿8Ë^¿žHµÀp]}À®˜A÷ÆûB›zB§£DBïBžnGB{ʱAK·ÀØYÀ2 [ÀŸýA1­AñÕÇA©ÂüAÑÖ_A×”{AÝŸVAÁS@¼ªéÀ¡ƒñÀè4LÀÀŸˆÁi Àç´ú¿¬¨ð@ôX‡AÄTA ˱A¤{@“iîÀËaüÁo7¿þkÇA¹”B!šB+OBGˆ{BIOœB.IBš_#C[sC „ØC:.C*àB²$£A€þ-Á¼VÁn&Á aÁòÍÀñrÉÀóÕäÀ—FÀdÉ”ÀZ’À§òÀØ. ÀÌ¡ÅÁÞ™Á#ÏŸÁ©‰Á iìÀ}+1@ü>êAC´„ABnÒA9Aõ¿|-¡Àë7¾À²ÖA¥9BHSêB/BB…ó¢B‡Î:B8oAA©ˆæAü…(BCç×BcjÇBfHÞB“bäBŽ'ÛBM ¡B4|wB2SÖAü_A'׿˜7ÔÀÚÞÁCÁ•ÓÁ Á Á0AkTsA„ŽÎAbÛ?ù³ÀuQÖ?ø@© K@¾„â@Æñ@µ¸ @Q±ÀWðøÀ\íÀuƒ¦ÀŽÿvÀ{‘¾À]Û‡À‹¿À›ÀŒBÀP¨À–¤À¾¡¤À¢êÀÊ[2À¾ñ©ÀÍ\°À×ÿÎÀ-j”A¢2ŽBrúBÌBœ{B'š‚AÒ=?ý×À Ae2A¹ƒA¡5µA§´A²iA•°&A”¿¸÷À8¥î¿~3¿×yÊÀ6ðí¿D'Ày¾ãר¿â%¸¿.9ö¿™#ÀnýƒÀ”AøœB›‹¸B§¸´B%¼BžvóB{Õ¸ALèÀ×ÐÀ/cÀ{]A9;AñøjAç!ãAç{ Aæ¾gAhîr¿ÌÞ¤À›xÀ„CßÀƒâðÀzÜ À{¾D¿ñÝ'¿t^1À)G¬AëÓ¬BÂâBÜ{}Bß[”BÚ0B¹AÖ!ÀÒ¸ÓÀŸ«À¶ûÇÀ0~ŽAg—HB÷ BKBÌòBÓWA¯°—@~‹À«#;ÀêPûÀ»'HÀµZÙAcªB™èBÀb•B·ZòB¶ŽB§°>AÒqÀøÌ Á‡ÂÁ ß•Á ¢œÀøçH>Ò¹ŒA©ákAÒ“A×ײAÝÇðAÁSþ@½Ü4À ÛÀçè\À¿ÚÁN¦Àç'Í¿¬F@õ#Aö6A רAÜã@” ÀÊìÍÁh­¿ùYÓA¹—B!¬(B+ÔBG³BIhaB5òBšW$C[ªC ŽYC;C,0B²:×AŠ Ám¨ÁTÁ ÜJÁ¹CÀðñ^ÀóÂkÀ•Ñ*À` ÀUÉ÷À¦ ÀÖŒÀʽçÁ¤‡Á#ÙÍÁ_»Á BRÀ{´q@üÆ ACý®AB±“A9&7A.†¿w£uÀês9À±ØQA¥ ´BHZ^B4FB…ÿÞB‡å|B8y«A©­7AüžnBCç—BcáBf]?B“cXBŽ6ÿBM_B4‘‡B2qÜAütAÌ¿’ÁiÀØâ—ÁyðÁI(Áµ Áÿ®ÁÕ-././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1714685814.0 astroscrappy-1.2.0/astroscrappy/tests/fake_data.py0000644000175100001770000000365214615003566022032 0ustar00runnerdocker# Licensed under a 3-clause BSD style license - see LICENSE.rst import numpy as np # Make a simple Gaussian function for testing purposes def gaussian(image_shape, x0, y0, brightness, fwhm): x = np.arange(image_shape[1]) y = np.arange(image_shape[0]) x2d, y2d = np.meshgrid(x, y) sig = fwhm / 2.35482 normfactor = brightness / 2.0 / np.pi * sig ** -2.0 exponent = -0.5 * sig ** -2.0 exponent *= (x2d - x0) ** 2.0 + (y2d - y0) ** 2.0 return normfactor * np.exp(exponent) def make_fake_data(): """ Generate fake data that can be used to test the detection and cleaning algorithms Returns ------- imdata : numpy float array Fake Image data crmask : numpy boolean array Boolean mask of locations of injected cosmic rays """ # Set a seed so that the tests are repeatable np.random.seed(200) # Create a simulated image to use in our tests imdata = np.zeros((1001, 1001), dtype=np.float32) # Add sky and sky noise imdata += 200 psf_sigma = 3.5 # Add some fake sources for i in range(100): x = np.random.uniform(low=0.0, high=1001) y = np.random.uniform(low=0.0, high=1001) brightness = np.random.uniform(low=1000., high=30000.) imdata += gaussian(imdata.shape, x, y, brightness, psf_sigma) # Add the poisson noise imdata = np.float32(np.random.poisson(imdata)) # Add readnoise imdata += np.random.normal(0.0, 10.0, size=(1001, 1001)) # Add 100 fake cosmic rays cr_x = np.random.randint(low=5, high=995, size=100) cr_y = np.random.randint(low=5, high=995, size=100) cr_brightnesses = np.random.uniform(low=1000.0, high=30000.0, size=100) imdata[cr_y, cr_x] += cr_brightnesses imdata = imdata.astype('f4') # Make a mask where the detected cosmic rays should be crmask = np.zeros((1001, 1001), dtype=bool) crmask[cr_y, cr_x] = True return imdata, crmask ././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1714685814.0 astroscrappy-1.2.0/astroscrappy/tests/test_astroscrappy.py0000644000175100001770000000203314615003566023714 0ustar00runnerdocker# Licensed under a 3-clause BSD style license - see LICENSE.rst from ..astroscrappy import detect_cosmics from . import fake_data import numpy as np def test_main(): imdata, expected_crmask = fake_data.make_fake_data() # Because our image only contains single cosmics, turn off # neighbor detection. Also, our cosmic rays are high enough # contrast that we can turn our detection threshold up. mask, _clean = detect_cosmics(imdata, readnoise=10., gain=1.0, sigclip=6, sigfrac=1.0) assert (mask == expected_crmask).sum() == (1001 * 1001) def test_with_convolve_fine_structure(): imdata, expected_crmask = fake_data.make_fake_data() # Convert from sigma to fwhm. Sigma is taken from the fake data utility. psf_fwhm = 3.5 * 2.0 * np.sqrt(2.0 * np.log(2.0)) mask, _clean = detect_cosmics(imdata, readnoise=10., gain=1.0, sigclip=6, sigfrac=1.0, fsmode='convolve', psffwhm=psf_fwhm) assert (mask == expected_crmask).sum() == (1001 * 1001) ././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1714685814.0 astroscrappy-1.2.0/astroscrappy/tests/test_cleaning.py0000644000175100001770000000616414615003566022753 0ustar00runnerdocker# Licensed under a 3-clause BSD style license - see LICENSE.rst import pytest from . import fake_data from ..astroscrappy import detect_cosmics @pytest.fixture def testdata(): # Get fake data to work on imdata, crmask = fake_data.make_fake_data() return imdata, crmask @pytest.mark.xfail def test_median_clean(testdata): imdata, crmask = testdata # Because our image only contains single cosmics, turn off # neighbor detection. Also, our cosmic rays are high enough # contrast that we can turn our detection threshold up. _mask, clean = detect_cosmics(imdata, readnoise=10., gain=1.0, sigclip=6, sigfrac=1.0, cleantype='median') assert (clean[crmask] != imdata[crmask]).sum() == crmask.sum() # Run it again on the clean data. We shouldn't find any new cosmic rays _mask2, _clean2 = detect_cosmics(clean, readnoise=10., gain=1.0, sigclip=6, sigfrac=1.0, cleantype='median') assert _mask2.sum() == 0 def test_medmask_clean(testdata): imdata, crmask = testdata # Because our image only contains single cosmics, turn off # neighbor detection. Also, our cosmic rays are high enough # contrast that we can turn our detection threshold up. _mask, clean = detect_cosmics(imdata, readnoise=10., gain=1.0, sigclip=6, sigfrac=1.0, cleantype='medmask') assert (clean[crmask] != imdata[crmask]).sum() == crmask.sum() # Run it again on the clean data. We shouldn't find any new cosmic rays _mask2, _clean2 = detect_cosmics(clean, readnoise=10., gain=1.0, sigclip=6, sigfrac=1.0, cleantype='medmask') assert _mask2.sum() == 0 def test_meanmask_clean(testdata): imdata, crmask = testdata # Because our image only contains single cosmics, turn off # neighbor detection. Also, our cosmic rays are high enough # contrast that we can turn our detection threshold up. _mask, clean = detect_cosmics(imdata, readnoise=10., gain=1.0, sigclip=6, sigfrac=1.0, cleantype='meanmask') assert (clean[crmask] != imdata[crmask]).sum() == crmask.sum() # Run it again on the clean data. We shouldn't find any new cosmic rays _mask2, _clean2 = detect_cosmics(clean, readnoise=10., gain=1.0, sigclip=6, sigfrac=1.0, cleantype='meanmask') assert _mask2.sum() == 0 def test_idw_clean(testdata): imdata, crmask = testdata # Because our image only contains single cosmics, turn off # neighbor detection. Also, our cosmic rays are high enough # contrast that we can turn our detection threshold up. _mask, clean = detect_cosmics(imdata, readnoise=10., gain=1.0, sigclip=6, sigfrac=1.0, cleantype='idw') assert (clean[crmask] != imdata[crmask]).sum() == crmask.sum() # Run it again on the clean data. We shouldn't find any new cosmic rays _mask2, _clean2 = detect_cosmics(clean, readnoise=10., gain=1.0, sigclip=6, sigfrac=1.0, cleantype='idw') assert _mask2.sum() == 0 ././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1714685814.0 astroscrappy-1.2.0/astroscrappy/tests/test_gmos.py0000644000175100001770000000302614615003566022132 0ustar00runnerdocker# Licensed under a 3-clause BSD style license - see LICENSE.rst import os import numpy as np import scipy.ndimage as ndi from astropy.io import fits from ..astroscrappy import detect_cosmics TESTFILE = os.path.join(os.path.abspath(os.path.dirname(__file__)), 'data', 'gmos.fits') def test_gmos(): """This test uses a small cutout from a standard observation with GMOS (S20190808S0048). The extracted region is [362:, 480:680], and the file has been reduced with DRAGONS. """ with fits.open(TESTFILE) as hdul: data = hdul['SCI'].data var = hdul['VAR'].data sky = hdul['SKYFIT'].data m1, _ = detect_cosmics(data, readnoise=4.24, gain=1.933) m2, _ = detect_cosmics(data, inbkg=sky, readnoise=4.24, gain=1.933) m3, _ = detect_cosmics(data, inbkg=sky, invar=var, readnoise=4.24, gain=1.933) cosmic1 = (slice(41, 72), slice(142, 161)) cosmic2 = (slice(117, 147), slice(35, 43)) # We must find 2 cosmic rays, but m1 (without bkg and var) also flags # 2 additional pixels that are identified as independent regions label, nb = ndi.label(m1) assert nb == 4 objects = ndi.find_objects(label) assert cosmic1 in objects assert cosmic2 in objects areas = sorted([np.sum(label == (i+1)) for i in range(nb)]) assert areas == [1, 1, 74, 93] for mask in m2, m3: label, nb = ndi.label(mask) assert nb == 2 objects = ndi.find_objects(label) assert objects[0] == cosmic1 assert objects[1] == cosmic2 ././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1714685814.0 astroscrappy-1.2.0/astroscrappy/tests/test_utils.py0000644000175100001770000001555514615003566022337 0ustar00runnerdocker# Licensed under a 3-clause BSD style license - see LICENSE.rst import numpy as np from numpy.testing import assert_allclose from ..utils import (median, optmed3, optmed5, optmed7, optmed9, optmed25, medfilt3, medfilt5, medfilt7, sepmedfilt3, sepmedfilt5, sepmedfilt7, sepmedfilt9, dilate3, dilate5, subsample, rebin, laplaceconvolve, convolve) import scipy.ndimage as ndi def test_median(): a = np.ascontiguousarray(np.random.random(1001)).astype('f4') assert np.float32(np.median(a)) == np.float32(median(a, 1001)) def test_optmed3(): a = np.ascontiguousarray(np.random.random(3)).astype('f4') assert np.float32(np.median(a)) == np.float32(optmed3(a)) def test_optmed5(): a = np.ascontiguousarray(np.random.random(5)).astype('f4') assert np.float32(np.median(a)) == np.float32(optmed5(a)) def test_optmed7(): a = np.ascontiguousarray(np.random.random(7)).astype('f4') assert np.float32(np.median(a)) == np.float32(optmed7(a)) def test_optmed9(): a = np.ascontiguousarray(np.random.random(9)).astype('f4') assert np.float32(np.median(a)) == np.float32(optmed9(a)) def test_optmed25(): a = np.ascontiguousarray(np.random.random(25)).astype('f4') assert np.float32(np.median(a)) == np.float32(optmed25(a)) def test_medfilt3(): a = np.ascontiguousarray(np.random.random((1001, 1001))).astype('f4') npmed3 = ndi.median_filter(a, size=(3, 3), mode='nearest') npmed3[:1, :] = a[:1, :] npmed3[-1:, :] = a[-1:, :] npmed3[:, :1] = a[:, :1] npmed3[:, -1:] = a[:, -1:] med3 = medfilt3(a) assert np.all(med3 == npmed3) def test_medfilt5(): a = np.ascontiguousarray(np.random.random((1001, 1001))).astype('f4') npmed5 = ndi.median_filter(a, size=(5, 5), mode='nearest') npmed5[:2, :] = a[:2, :] npmed5[-2:, :] = a[-2:, :] npmed5[:, :2] = a[:, :2] npmed5[:, -2:] = a[:, -2:] med5 = medfilt5(a) assert np.all(med5 == npmed5) def test_medfilt7(): a = np.ascontiguousarray(np.random.random((1001, 1001))).astype('f4') npmed7 = ndi.median_filter(a, size=(7, 7), mode='nearest') npmed7[:3, :] = a[:3, :] npmed7[-3:, :] = a[-3:, :] npmed7[:, :3] = a[:, :3] npmed7[:, -3:] = a[:, -3:] med7 = medfilt7(a) assert np.all(med7 == npmed7) def test_sepmedfilt3(): a = np.ascontiguousarray(np.random.random((1001, 1001))).astype('f4') npmed3 = ndi.median_filter(a, size=(1, 3), mode='nearest') npmed3[:, :1] = a[:, :1] npmed3[:, -1:] = a[:, -1:] npmed3 = ndi.median_filter(npmed3, size=(3, 1), mode='nearest') npmed3[:1, :] = a[:1, :] npmed3[-1:, :] = a[-1:, :] npmed3[:, :1] = a[:, :1] npmed3[:, -1:] = a[:, -1:] med3 = sepmedfilt3(a) assert np.all(med3 == npmed3) def test_sepmedfilt5(): a = np.ascontiguousarray(np.random.random((1001, 1001))).astype('f4') npmed5 = ndi.median_filter(a, size=(1, 5), mode='nearest') npmed5[:, :2] = a[:, :2] npmed5[:, -2:] = a[:, -2:] npmed5 = ndi.median_filter(npmed5, size=(5, 1), mode='nearest') npmed5[:2, :] = a[:2, :] npmed5[-2:, :] = a[-2:, :] npmed5[:, :2] = a[:, :2] npmed5[:, -2:] = a[:, -2:] med5 = sepmedfilt5(a) assert np.all(med5 == npmed5) def test_sepmedfilt7(): a = np.ascontiguousarray(np.random.random((1001, 1001))).astype('f4') npmed7 = ndi.median_filter(a, size=(1, 7), mode='nearest') npmed7[:, :3] = a[:, :3] npmed7[:, -3:] = a[:, -3:] npmed7 = ndi.median_filter(npmed7, size=(7, 1), mode='nearest') npmed7[:3, :] = a[:3, :] npmed7[-3:, :] = a[-3:, :] npmed7[:, :3] = a[:, :3] npmed7[:, -3:] = a[:, -3:] med7 = sepmedfilt7(a) assert np.all(med7 == npmed7) def test_sepmedfilt9(): a = np.ascontiguousarray(np.random.random((1001, 1001))).astype('f4') npmed9 = ndi.median_filter(a, size=(1, 9), mode='nearest') npmed9[:, :4] = a[:, :4] npmed9[:, -4:] = a[:, -4:] npmed9 = ndi.median_filter(npmed9, size=(9, 1), mode='nearest') npmed9[:4, :] = a[:4, :] npmed9[-4:, :] = a[-4:, :] npmed9[:, :4] = a[:, :4] npmed9[:, -4:] = a[:, -4:] med9 = sepmedfilt9(a) assert np.all(med9 == npmed9) def test_dilate5(): # Put 5% of the pixels into a mask a = np.zeros((1001, 1001), dtype=bool) a[np.random.random((1001, 1001)) < 0.05] = True kernel = np.ones((5, 5)) kernel[0, 0] = 0 kernel[0, 4] = 0 kernel[4, 0] = 0 kernel[4, 4] = 0 # Make a zero padded array for the numpy version to operate paddeda = np.zeros((1005, 1005), dtype=bool) paddeda[2:-2, 2:-2] = a[:, :] npdilate = ndi.binary_dilation(np.ascontiguousarray(paddeda), structure=kernel, iterations=2) cdilate = dilate5(a, 2) assert np.all(npdilate[2:-2, 2:-2] == cdilate) def test_dilate3(): # Put 5% of the pixels into a mask a = np.zeros((1001, 1001), dtype=bool) a[np.random.random((1001, 1001)) < 0.05] = True kernel = np.ones((3, 3)) npgrow = ndi.binary_dilation(np.ascontiguousarray(a), structure=kernel, iterations=1) cgrow = dilate3(a) npgrow[:, 0] = a[:, 0] npgrow[:, -1] = a[:, -1] npgrow[0, :] = a[0, :] npgrow[-1, :] = a[-1, :] assert np.all(npgrow == cgrow) def test_subsample(): a = np.ascontiguousarray(np.random.random((1001, 1001))).astype('f4') npsubsamp = np.zeros((a.shape[0] * 2, a.shape[1] * 2), dtype=np.float32) for i in range(a.shape[0]): for j in range(a.shape[1]): npsubsamp[2 * i, 2 * j] = a[i, j] npsubsamp[2 * i + 1, 2 * j] = a[i, j] npsubsamp[2 * i, 2 * j + 1] = a[i, j] npsubsamp[2 * i + 1, 2 * j + 1] = a[i, j] csubsamp = subsample(a) assert np.all(npsubsamp == csubsamp) def test_rebin(): a = np.ascontiguousarray(np.random.random((2002, 2002)), dtype=np.float32) a = a.astype('f4') nprebin = np.zeros((1001, 1001), dtype=np.float32).astype('f4') for i in range(1001): for j in range(1001): nprebin[i, j] = (a[2 * i, 2 * j] + a[2 * i + 1, 2 * j] + a[2 * i, 2 * j + 1] + a[2 * i + 1, 2 * j + 1]) nprebin[i, j] /= np.float32(4.0) crebin = rebin(a) assert_allclose(crebin, nprebin, rtol=0, atol=1.e-6) def test_laplaceconvolve(): a = np.ascontiguousarray(np.random.random((1001, 1001))).astype('f4') k = np.array([[0.0, -1.0, 0.0], [-1.0, 4.0, -1.0], [0.0, -1.0, 0.0]]) k = k.astype(' np.PyArray_DATA(dsub) cdef float * outdsubptr = < float * > np.PyArray_DATA(output) with nogil: PySubsample(dsubptr, outdsubptr, nx, ny) return output def rebin(np.ndarray[np.float32_t, ndim=2, mode='c', cast=True] drebin): """rebin(drebin)\n Rebin an array 2x2. Rebin the array by block averaging 4 pixels back into 1. Parameters ---------- drebin : float numpy array Array to be rebinned 2x2. Returns ------- output : float numpy array Rebinned array. The size of the output array will be 2 times smaller than drebin. Notes ----- This is effectively the opposite of subsample (although subsample does not do an average). The array needs to be C-contiguous order. Wrapper for PyRebin in imutils. """ cdef int nx = drebin.shape[1] / 2 cdef int ny = drebin.shape[0] / 2 # Allocate the output array here so that Python tracks the memory and will # free the memory when we are finished with the output array. output = np.zeros((ny, nx), dtype=np.float32) cdef float * drebinptr = < float * > np.PyArray_DATA(drebin) cdef float * outdrebinptr = < float * > np.PyArray_DATA(output) with nogil: PyRebin(drebinptr, outdrebinptr, nx, ny) return output def convolve(np.ndarray[np.float32_t, ndim=2, mode='c', cast=True] dconv, np.ndarray[np.float32_t, ndim=2, mode='c', cast=True] kernel): """convolve(dconv, kernel)\n Convolve an array with a kernel. Parameters ---------- dconv : float numpy array Array to be convolved. kernel : float numpy array Kernel to use in the convolution. Returns ------- output : float numpy array Convolved array. Notes ----- Both the data and kernel arrays need to be C-contiguous order. Wrapper for PyConvolve in imutils. """ cdef int nx = dconv.shape[1] cdef int ny = dconv.shape[0] # Allocate the output array here so that Python tracks the memory and will # free the memory when we are finished with the output array. output = np.zeros((ny, nx), dtype=np.float32) cdef float * dconvptr = < float * > np.PyArray_DATA(dconv) cdef float * outdconvptr = < float * > np.PyArray_DATA(output) cdef int knx = kernel.shape[1] cdef int kny = kernel.shape[0] cdef float * kernptr = < float * > np.PyArray_DATA(kernel) with nogil: PyConvolve(dconvptr, kernptr, outdconvptr, nx, ny, knx, kny) return output def laplaceconvolve(np.ndarray[np.float32_t, ndim=2, mode='c', cast=True] dl): """laplaceconvolve(dl)\n Convolve an array with the Laplacian kernel. Convolve with the discrete version of the Laplacian operator with kernel:\n 0 -1 0\n -1 4 -1\n 0 -1 0\n Parameters ---------- dl : float numpy array Array to be convolved. Returns ------- output: float numpy array Convolved array. Notes ----- The array needs to be C-contiguous order. Wrapper for PyLaplaceConvolve in imutils. """ cdef int nx = dl.shape[1] cdef int ny = dl.shape[0] # Allocate the output array here so that Python tracks the memory and will # free the memory when we are finished with the output array. output = np.zeros((ny, nx), dtype=np.float32) cdef float * dlapptr = < float * > np.PyArray_DATA(dl) cdef float * outdlapptr = < float * > np.PyArray_DATA(output) with nogil: PyLaplaceConvolve(dlapptr, outdlapptr, nx, ny) return output def dilate3(np.ndarray[np.uint8_t, ndim=2, mode='c', cast=True] dgrow): """dilate3(dgrow)\n Perform a boolean dilation on an array. Parameters ---------- dgrow : boolean numpy array Array to dilate. Returns ------- output : boolean numpy array Dilated array. Notes ----- Dilation is the boolean equivalent of a convolution but using logical ors instead of a sum. We apply the following kernel:\n 1 1 1\n 1 1 1\n 1 1 1\n The binary dilation is not computed for a 1 pixel border around the image. These pixels are copied from the input data. The array needs to be C-contiguous order. Wrapper for PyDilate3 in imutils. """ cdef int nx = dgrow.shape[1] cdef int ny = dgrow.shape[0] # Allocate the output array here so that Python tracks the memory and will # free the memory when we are finished with the output array. output = np.zeros((ny, nx), dtype=np.bool_) cdef uint8_t * dgrowptr = < uint8_t * > np.PyArray_DATA(dgrow) cdef uint8_t * outdgrowptr = < uint8_t * > np.PyArray_DATA(output) with nogil: PyDilate3(dgrowptr, outdgrowptr, nx, ny) return output def dilate5(np.ndarray[np.uint8_t, ndim=2, mode='c', cast=True] ddilate, int niter): """dilate5(data, niter)\n Do niter iterations of boolean dilation on an array. Parameters ---------- ddilate : boolean numpy array Array to dilate. niter : int Number of iterations. Returns ------- output : boolean numpy array Dilated array. Notes ----- Dilation is the boolean equivalent of a convolution but using logical ors instead of a sum. We apply the following kernel:\n 0 1 1 1 0\n 1 1 1 1 1\n 1 1 1 1 1\n 1 1 1 1 1\n 0 1 1 1 0\n The edges are padded with zeros so that the dilation operator is defined for all pixels. The array needs to be C-contiguous order. Wrapper for PyDilate5 in imutils. """ cdef int nx = ddilate.shape[1] cdef int ny = ddilate.shape[0] # Allocate the output array here so that Python tracks the memory and will # free the memory when we are finished with the output array. output = np.zeros((ny, nx), dtype=bool) cdef uint8_t * ddilateptr = < uint8_t * > np.PyArray_DATA(ddilate) cdef uint8_t * outddilateptr = < uint8_t * > np.PyArray_DATA(output) with nogil: PyDilate5(ddilateptr, outddilateptr, niter, nx, ny) return output ././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1714685814.0 astroscrappy-1.2.0/astroscrappy/utils/imutils.c0000644000175100001770000004762414615003566021420 0ustar00runnerdocker/* * Author: Curtis McCully * October 2014 * Licensed under a 3-clause BSD style license - see LICENSE.rst * * Originally written in C++ in 2011 * See also https://github.com/cmccully/lacosmicx * * This file contains image utility functions for SCRAPPY. These are the most * computationally expensive pieces of the calculation so they have been ported * to C. * * Many thanks to Nicolas Devillard who wrote the optimized methods for finding * the median and placed them in the public domain. I have noted in the * comments places that use Nicolas Devillard's code. * * Parallelization has been achieved using OpenMP. Using a compiler that does * not support OpenMP, e.g. clang currently, the code should still compile and * run serially without issue. I have tried to be explicit as possible about * specifying which variables are private and which should be shared, although * we never actually have any shared variables. We use firstprivate instead. * This does mean that it is important that we never have two threads write to * the same memory position at the same time. * * All calculations are done with 32 bit floats to keep the memory footprint * small. */ #include #include "imutils.h" /* Subsample an array 2x2 given an input array data with size nx x ny. Each * pixel is replicated into 4 pixels; no averaging is performed. The results * are saved in the output array. The output array should already be allocated * as we work on it in place. Data should be striped in the x direction such * that the memory location of pixel i,j is data[nx *j + i]. */ void PySubsample(float* data, float* output, int nx, int ny) { PyDoc_STRVAR(PySubsample__doc__, "PySubample(data, output, nx, ny) -> void\n\n" "Subsample an array 2x2 given an input array data with size " "nx x ny.The results are saved in the output array. The output " "array should already be allocated as we work on it in place. Each" " pixel is replicated into 4 pixels; no averaging is performed. " "Data should be striped in the x direction such that the memory " "location of pixel i,j is data[nx *j + i]."); /* Precalculate the new length; minor optimization */ int padnx = 2 * nx; /* Loop indices */ int i, j, nxj, padnxj; /* Loop over all pixels */ #pragma omp parallel for firstprivate(data, output, nx, ny, padnx) \ private(i, j, nxj, padnxj) for (j = 0; j < ny; j++) { nxj = nx * j; padnxj = 2 * padnx * j; for (i = 0; i < nx; i++) { /* Copy the pixel value into a 2x2 grid on the output image */ output[2 * i + padnxj] = data[i + nxj]; output[2 * i + padnxj + padnx] = data[i + nxj]; output[2 * i + 1 + padnxj + padnx] = data[i + nxj]; output[2 * i + 1 + padnxj] = data[i + nxj]; } } return; } /* Rebin an array 2x2, with size (2 * nx) x (2 * ny). Rebin the array by block * averaging 4 pixels back into 1. This is effectively the opposite of * subsample (although subsample does not do an average). The results are saved * in the output array. The output array should already be allocated as we work * on it in place. Data should be striped in the x direction such that the * memory location of pixel i,j is data[nx *j + i]. */ void PyRebin(float* data, float* output, int nx, int ny) { PyDoc_STRVAR(PyRebin__doc__, "PyRebin(data, output, nx, ny) -> void\n \n" "Rebin an array 2x2, with size (2 * nx) x (2 * ny). Rebin the " "array by block averaging 4 pixels back into 1. This is " "effectively the opposite of subsample (although subsample does " "not do an average). The results are saved in the output array. " "The output array should already be allocated as we work on it in " "place. Data should be striped in the x direction such that the " "memory location of pixel i,j is data[nx *j + i]."); /* Size of original array */ int padnx = nx * 2; /* Loop variables */ int i, j, nxj, padnxj; /* Pixel value p. Each thread needs its own copy of this variable so we * wait to initialize it until the pragma below */ float p; #pragma omp parallel for firstprivate(output, data, nx, ny, padnx) \ private(i, j, nxj, padnxj, p) /*Loop over all of the pixels */ for (j = 0; j < ny; j++) { nxj = nx * j; padnxj = 2 * padnx * j; for (i = 0; i < nx; i++) { p = data[2 * i + padnxj]; p += data[2 * i + padnxj + padnx]; p += data[2 * i + 1 + padnxj + padnx]; p += data[2 * i + 1 + padnxj]; p /= 4.0; output[i + nxj] = p; } } return; } /* Convolve an image of size nx x ny with a kernel of size kernx x kerny. The * results are saved in the output array. The output array should already be * allocated as we work on it in place. Data and kernel should both be striped * in the x direction such that the memory location of pixel i,j is * data[nx *j + i]. */ void PyConvolve(float* data, float* kernel, float* output, int nx, int ny, int kernx, int kerny) { PyDoc_STRVAR(PyConvolve__doc__, "PyConvolve(data, kernel, output, nx, ny, kernx, kerny) -> void\n\n" "Convolve an image of size nx x ny with a a kernel of size " "kernx x kerny. The results are saved in the output array. The " "output array should already be allocated as we work on it in " "place. Data and kernel should both be striped along the x " "direction such that the memory location of pixel i,j is " "data[nx *j + i]."); /* Get the width of the borders that we will pad with zeros */ int bnx = (kernx - 1) / 2; int bny = (kerny - 1) / 2; /* Calculate the dimensions of the array including padded border */ int padnx = nx + kernx - 1; int padny = ny + kerny - 1; /* Get the total number of pixels in the padded array */ int padnxny = padnx * padny; /*Get the total number of pixels in the output image */ int nxny = nx * ny; /*Allocate the padded array */ float* padarr = (float *) malloc(padnxny * sizeof(float)); /* Loop variables. These should all be thread private. */ int i, j; int nxj; int padnxj; /* Inner loop variables. Again thread private. */ int k, l; int kernxl, padnxl; /* Define a sum variable to use in the convolution calculation. Each * thread needs its own copy of this so it should be thread private. */ float sum; /* Precompute maximum good index in each dimension */ int xmaxgood = nx + bnx; int ymaxgood = ny + bny; /* Set the borders of padarr = 0.0 * Fill the rest of the padded array with the input data. */ #pragma omp parallel for \ firstprivate(padarr, data, nx, padnx, padny, bnx, bny, xmaxgood, ymaxgood)\ private(nxj, padnxj, i, j) for (j = 0; j < padny; j++) { padnxj = padnx * j; nxj = nx * (j - bny); for (i = 0; i < padnx; i++) { if (i < bnx || j < bny || j >= ymaxgood || i >= xmaxgood) { padarr[padnxj + i] = 0.0; } else { padarr[padnxj + i] = data[nxj + i - bnx]; } } } /* Calculate the convolution */ /* Loop over all pixels */ #pragma omp parallel for \ firstprivate(padarr, output, nx, ny, padnx, bnx, bny, kernx) \ private(nxj, padnxj, kernxl, padnxl, i, j, k, l, sum) for (j = 0; j < ny; j++) { nxj = nx * j; /* Note the + bvy in padnxj */ padnxj = padnx * (j + bny); for (i = 0; i < nx; i++) { sum = 0.0; /* Note that the sums in the definition of the convolution go from * -border width to + border width */ for (l = -bny; l <= bny; l++) { padnxl = padnx * (l + j + bny); kernxl = kernx * (-l + bny); for (k = -bnx; k <= bnx; k++) { sum += kernel[bnx - k + kernxl] * padarr[padnxl + k + i + bnx]; } } output[nxj + i] = sum; } } free(padarr); return; } /* Convolve an image of size nx x ny the following kernel: * 0 -1 0 * -1 4 -1 * 0 -1 0 * The results are saved in the output array. The output array should * already be allocated as we work on it in place. * This is a discrete version of the Laplacian operator. * Data should be striped in the x direction such that the memory location of * pixel i,j is data[nx *j + i]. */ void PyLaplaceConvolve(float* data, float* output, int nx, int ny) { PyDoc_STRVAR(PyLaplaceConvolve__doc__, "PyLaplaceConvolve(data, output, nx, ny) -> void\n\n" "Convolve an image of size nx x ny the following kernel:\n" " 0 -1 0\n" "-1 4 -1\n" " 0 -1 0\n" "This is a discrete version of the Laplacian operator. The results" " are saved in the output array. The output array should already " "be allocated as we work on it in place.Data should be striped in " "the x direction such that the memory location of pixel i,j is " "data[nx *j + i]."); /* Precompute the total number of pixels in the image */ int nxny = nx * ny; /* Loop variables */ int i, j, nxj; /* Pixel value p. Each thread will need its own copy of this so we need to * make it private*/ float p; /* Because we know the form of the kernel, we can short circuit the * convolution and calculate the results with inner nest for loops. */ /*Loop over all of the pixels except the edges which we will do explicitly * below */ #pragma omp parallel for firstprivate(nx, ny, output, data) \ private(i, j, nxj, p) for (j = 1; j < ny - 1; j++) { nxj = nx * j; for (i = 1; i < nx - 1; i++) { p = 4.0 * data[nxj + i]; p -= data[i + 1 + nxj]; p -= data[i - 1 + nxj]; p -= data[i + nxj + nx]; p -= data[i + nxj - nx]; output[nxj + i] = p; } } /* Leave the corners until the very end */ #pragma omp parallel firstprivate(output, data, nx, nxny) private(i) /* Top and Bottom Rows */ for (i = 1; i < nx - 1; i++) { output[i] = 4.0 * data[i] - data[i + 1] - data[i - 1] - data[i + nx]; p = 4.0 * data[i + nxny - nx]; p -= data[i + 1 + nxny - nx]; p -= data[i + nxny - nx - 1]; p -= data[i - nx + nxny - nx]; output[i + nxny - nx] = p; } #pragma omp parallel firstprivate(output, data, nx, ny) private(j, nxj) /* First and Last Column */ for (j = 1; j < ny - 1; j++) { nxj = nx * j; p = 4.0 * data[nxj]; p -= data[nxj + 1]; p -= data[nxj + nx]; p -= data[nxj - nx]; output[nxj] = p; p = 4.0 * data[nxj + nx - 1]; p -= data[nxj + nx - 2]; p -= data[nxj + nx + nx - 1]; p -= data[nxj - 1]; output[nxj + nx - 1] = p; } /* Bottom Left Corner */ output[0] = 4.0 * data[0] - data[1] - data[nx]; /* Bottom Right Corner */ output[nx - 1] = 4.0 * data[nx - 1] - data[nx - 2] - data[nx + nx - 1]; /* Top Left Corner */ p = 4.0 * data[nxny - nx]; p -= data[nxny - nx + 1]; p -= data[nxny - nx - nx]; output[nxny - nx] = p; /* Top Right Corner */ p = 4.0 * data[nxny - 1]; p -= data[nxny - 2]; p -= data[nxny - 1 - nx]; output[nxny - 1] = p; return; } /* Perform a boolean dilation on an array of size nx x ny. The results are * saved in the output array. The output array should already be allocated as * we work on it in place. * Dilation is the boolean equivalent of a convolution but using logical ors * instead of a sum. * We apply the following kernel: * 1 1 1 * 1 1 1 * 1 1 1 * The binary dilation is not computed for a 1 pixel border around the image. * These pixels are copied from the input data. Data should be striped along * the x direction such that the memory location of pixel i,j is * data[i + nx * j]. */ void PyDilate3(bool* data, bool* output, int nx, int ny) { PyDoc_STRVAR(PyDilate3__doc__, "PyDilate3(data, output, nx, ny) -> void\n\n" "Perform a boolean dilation on an array of size nx x ny. The " "results are saved in the output array which should already be " "allocated as we work on it in place. " "Dilation is the boolean equivalent of a convolution but using " "logical or instead of a sum. We apply a 3x3 kernel of all ones. " "Dilation is not computed for a 1 pixel border which is copied " "from the input data. Data should be striped along the x-axis " "such that the location of pixel i,j is data[i + nx * j]."); /* Precompute the total number of pixels; minor optimization */ int nxny = nx * ny; /* Loop variables */ int i, j, nxj; /* Pixel value p. Each thread needs its own unique copy of this so we don't initialize this until the pragma below. */ bool p; #pragma omp parallel for firstprivate(output, data, nxny, nx, ny) \ private(i, j, nxj, p) /* Loop through all of the pixels excluding the border */ for (j = 1; j < ny - 1; j++) { nxj = nx * j; for (i = 1; i < nx - 1; i++) { /*Start in the middle and work out */ p = data[i + nxj]; /* Right 1 */ p = p || data[i + 1 + nxj]; /* Left 1 */ p = p || data[i - 1 + nxj]; /* Up 1 */ p = p || data[i + nx + nxj]; /* Down 1 */ p = p || data[i - nx + nxj]; /* Up 1 Right 1 */ p = p || data[i + 1 + nx + nxj]; /* Up 1 Left 1 */ p = p || data[i - 1 + nx + nxj]; /* Down 1 Right 1 */ p = p || data[i + 1 - nx + nxj]; /* Down 1 Left 1 */ p = p || data[i - 1 - nx + nxj]; output[i + nxj] = p; } } #pragma omp parallel firstprivate(output, data, nx, nxny) private(i) /* For the borders, copy the data from the input array */ for (i = 0; i < nx; i++) { output[i] = data[i]; output[nxny - nx + i] = data[nxny - nx + i]; } #pragma omp parallel firstprivate(output, data, nx, ny) private(j, nxj) for (j = 0; j < ny; j++) { nxj = nx * j; output[nxj] = data[nxj]; output[nxj - 1 + nx] = data[nxj - 1 + nx]; } return; } /* Do niter iterations of boolean dilation on an array of size nx x ny. The * results are saved in the output array. The output array should already be * allocated as we work on it in place. * Dilation is the boolean equivalent of a convolution but using logical ors * instead of a sum. * We apply the following kernel: * 0 1 1 1 0 * 1 1 1 1 1 * 1 1 1 1 1 * 1 1 1 1 1 * 0 1 1 1 0 * The edges are padded with zeros so that the dilation operator is defined for * all pixels. Data should be striped along the x direction such that the * memory location of pixel i,j is data[i + nx * j]. */ void PyDilate5(bool* data, bool* output, int niter, int nx, int ny) { PyDoc_STRVAR(PyDilate5__doc__, "PyDilate5(data, output, nx, ny) -> void\n\n" "Do niter iterations of boolean dilation on an array of size " "nx x ny. The results are saved in the output array. The output " "array should already be allocated as we work on it in place. " "Dilation is the boolean equivalent of a convolution but using " "logical ors instead of a sum. We apply the following kernel:\n" "0 1 1 1 0\n" "1 1 1 1 1\n" "1 1 1 1 1\n" "1 1 1 1 1\n" "0 1 1 1 0\n" "Data should be striped along the x direction such that the " "location of pixel i,j is data[i + nx * j]."); /* Pad the array with a border of zeros */ int padnx = nx + 4; int padny = ny + 4; /* Precompute the total number of pixels; minor optimization */ int padnxny = padnx * padny; int nxny = nx * ny; /* The padded array to work on */ bool* padarr = (bool *) malloc(padnxny * sizeof(bool)); /*Loop indices */ int i, j, nxj, padnxj; int iter; /* Pixel value p. This needs to be unique for each thread so we initialize * it below inside the pragma. */ bool p; #pragma omp parallel firstprivate(padarr, padnx, padnxny) private(i) /* Initialize the borders of the padded array to zero */ for (i = 0; i < padnx; i++) { padarr[i] = false; padarr[i + padnx] = false; padarr[padnxny - padnx + i] = false; padarr[padnxny - padnx - padnx + i] = false; } #pragma omp parallel firstprivate(padarr, padnx, padny) private(j, padnxj) for (j = 0; j < padny; j++) { padnxj = padnx * j; padarr[padnxj] = false; padarr[padnxj + 1] = false; padarr[padnxj + padnx - 1] = false; padarr[padnxj + padnx - 2] = false; } #pragma omp parallel firstprivate(output, data, nxny) private(i) /* Initialize the output array to the input data */ for (i = 0; i < nxny; i++) { output[i] = data[i]; } /* Outer iteration loop */ for (iter = 0; iter < niter; iter++) { #pragma omp parallel for firstprivate(padarr, output, nx, ny, padnx, iter) \ private(nxj, padnxj, i, j) /* Initialize the padded array to the output from the latest * iteration*/ for (j = 0; j < ny; j++) { padnxj = padnx * j; nxj = nx * j; for (i = 0; i < nx; i++) { padarr[i + 2 + padnx + padnx + padnxj] = output[i + nxj]; } } /* Loop over all pixels */ #pragma omp parallel for firstprivate(padarr, output, nx, ny, padnx, iter) \ private(nxj, padnxj, i, j, p) for (j = 0; j < ny; j++) { nxj = nx * j; /* Note the + 2 padding in padnxj */ padnxj = padnx * (j + 2); for (i = 0; i < nx; i++) { /* Start with the middle pixel and work out */ p = padarr[i + 2 + padnxj]; /* Right 1 */ p = p || padarr[i + 3 + padnxj]; /* Left 1 */ p = p || padarr[i + 1 + padnxj]; /* Up 1 */ p = p || padarr[i + 2 + padnx + padnxj]; /* Down 1 */ p = p || padarr[i + 2 - padnx + padnxj]; /* Up 1 Right 1 */ p = p || padarr[i + 3 + padnx + padnxj]; /* Up 1 Left 1 */ p = p || padarr[i + 1 + padnx + padnxj]; /* Down 1 Right 1 */ p = p || padarr[i + 3 - padnx + padnxj]; /* Down 1 Left 1 */ p = p || padarr[i + 1 - padnx + padnxj]; /* Right 2 */ p = p || padarr[i + 4 + padnxj]; /* Left 2 */ p = p || padarr[i + padnxj]; /* Up 2 */ p = p || padarr[i + 2 + padnx + padnx + padnxj]; /* Down 2 */ p = p || padarr[i + 2 - padnx - padnx + padnxj]; /* Right 2 Up 1 */ p = p || padarr[i + 4 + padnx + padnxj]; /* Right 2 Down 1 */ p = p || padarr[i + 4 - padnx + padnxj]; /* Left 2 Up 1 */ p = p || padarr[i + padnx + padnxj]; /* Left 2 Down 1 */ p = p || padarr[i - padnx + padnxj]; /* Up 2 Right 1 */ p = p || padarr[i + 3 + padnx + padnx + padnxj]; /* Up 2 Left 1 */ p = p || padarr[i + 1 + padnx + padnx + padnxj]; /* Down 2 Right 1 */ p = p || padarr[i + 3 - padnx - padnx + padnxj]; /* Down 2 Left 1 */ p = p || padarr[i + 1 - padnx - padnx + padnxj]; output[i + nxj] = p; } } } free(padarr); return; } ././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1714685814.0 astroscrappy-1.2.0/astroscrappy/utils/imutils.h0000644000175100001770000000702514615003566021414 0ustar00runnerdocker/* * imutils.h * * Author: Curtis McCully * October 2014 * * Licensed under a 3-clause BSD style license - see LICENSE.rst */ #ifndef IMUTILS_H_ #define IMUTILS_H_ /* Including definitions of the standard int types is necesssary for Windows, * and does no harm on other platforms. */ #include /* Define a bool type because there isn't one built in ANSI C */ typedef uint8_t bool; #define true 1 #define false 0 /* Subsample an array 2x2 given an input array data with size nx x ny. Each * pixel is replicated into 4 pixels; no averaging is performed. The results * are saved in the output array. The output array should already be allocated * as we work on it in place. Data should be striped in the x direction such * that the memory location of pixel i,j is data[nx *j + i]. */ void PySubsample(float* data, float* output, int nx, int ny); /* Rebin an array 2x2, with size (2 * nx) x (2 * ny). Rebin the array by block * averaging 4 pixels back into 1. This is effectively the opposite of * subsample (although subsample does not do an average). The results are saved * in the output array. The output array should already be allocated as we work * on it in place. Data should be striped in the x direction such that the * memory location of pixel i,j is data[nx *j + i]. */ void PyRebin(float* data, float* output, int nx, int ny); /* Convolve an image of size nx x ny with a kernel of size kernx x kerny. The * results are saved in the output array. The output array should already be * allocated as we work on it in place. Data and kernel should both be striped * in the x direction such that the memory location of pixel i,j is * data[nx *j + i]. */ void PyConvolve(float* data, float* kernel, float* output, int nx, int ny, int kernx, int kerny); /* Convolve an image of size nx x ny the following kernel: * 0 -1 0 * -1 4 -1 * 0 -1 0 * The results are saved in the output array. The output array should * already be allocated as we work on it in place. * This is a discrete version of the Laplacian operator. * Data should be striped in the x direction such that the memory location of * pixel i,j is data[nx *j + i]. */ void PyLaplaceConvolve(float* data, float* output, int nx, int ny); /* Perform a boolean dilation on an array of size nx x ny. The results are * saved in the output array. The output array should already be allocated as * we work on it in place. * Dilation is the boolean equivalent of a convolution but using logical ors * instead of a sum. * We apply the following kernel: * 1 1 1 * 1 1 1 * 1 1 1 * The binary dilation is not computed for a 1 pixel border around the image. * These pixels are copied from the input data. Data should be striped along * the x direction such that the memory location of pixel i,j is * data[i + nx * j]. */ void PyDilate3(bool* data, bool* output, int nx, int ny); /* Do niter iterations of boolean dilation on an array of size nx x ny. The * results are saved in the output array. The output array should already be * allocated as we work on it in place. * Dilation is the boolean equivalent of a convolution but using logical ors * instead of a sum. * We apply the following kernel: * 0 1 1 1 0 * 1 1 1 1 1 * 1 1 1 1 1 * 1 1 1 1 1 * 0 1 1 1 0 * The edges are padded with zeros so that the dilation operator is defined for * all pixels. Data should be striped along the x direction such that the * memory location of pixel i,j is data[i + nx * j]. */ void PyDilate5(bool* data, bool* output, int iter, int nx, int ny); #endif /* IMUTILS_H_ */ ././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1714685814.0 astroscrappy-1.2.0/astroscrappy/utils/median_utils.pxd0000644000175100001770000000051314615003566022742 0ustar00runnerdocker# cython: language_level=3 """ Header file for Cython functions in the utils package. This allows the Cython code to call these routines directly without requiring the GIL. """ """ Calculate the median on the first n elements of C float array without requiring the GIL. """ cdef float cymedian(float* aptr, int n) noexcept nogil ././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1714685814.0 astroscrappy-1.2.0/astroscrappy/utils/median_utils.pyx0000644000175100001770000003156314615003566023000 0ustar00runnerdocker# Licensed under a 3-clause BSD style license - see LICENSE.rst # cython: boundscheck=False, nonecheck=False, wraparound=False, language_level=3, cdivision=True """ Name : median_utils Author : Curtis McCully Date : October 2014 """ import numpy as np cimport numpy as np np.import_array() cdef extern from "medutils.h": float PyMedian(float * a, int n) nogil float PyOptMed3(float * a) nogil float PyOptMed5(float * a) nogil float PyOptMed7(float * a) nogil float PyOptMed9(float * a) nogil float PyOptMed25(float * a) nogil void PyMedFilt3(float * data, float * output, int nx, int ny) nogil void PyMedFilt5(float * data, float * output, int nx, int ny) nogil void PyMedFilt7(float * data, float * output, int nx, int ny) nogil void PySepMedFilt3(float * data, float * output, int nx, int ny) nogil void PySepMedFilt5(float * data, float * output, int nx, int ny) nogil void PySepMedFilt7(float * data, float * output, int nx, int ny) nogil void PySepMedFilt9(float * data, float * output, int nx, int ny) nogil """ Wrappers for the C functions in medutils.c """ def median(np.ndarray[np.float32_t, mode='c', cast=True] a, int n): """median(a, n)\n Find the median of the first n elements of an array. Parameters ---------- a : float numpy array Input array to find the median. n : int Number of elements of the array to median. Returns ------- med : float The median value. Notes ----- Wrapper for PyMedian in medutils. """ cdef float * aptr = < float * > np.PyArray_DATA(a) cdef float med = 0.0 with nogil: med = PyMedian(aptr, n) return med cdef float cymedian(float* a, int n) noexcept nogil: """cymedian(a, n)\n Cython function to calculate the median without requiring the GIL. :param a: :param n: :return: """ cdef float med = 0.0 med = PyMedian(a, n) return med def optmed3(np.ndarray[np.float32_t, ndim=1, mode='c', cast=True] a): """optmed3(a)\n Optimized method to find the median value of an array of length 3. Parameters ---------- a : float numpy array Input array to find the median. Must be length 3. Returns ------- med3 : float The median of the 3-element array. Notes ----- Wrapper for PyOptMed3 in medutils. """ cdef float * aptr3 = < float * > np.PyArray_DATA(a) cdef float med3 = 0.0 with nogil: med3 = PyOptMed3(aptr3) return med3 def optmed5(np.ndarray[np.float32_t, ndim=1, mode='c', cast=True] a): """optmed5(a)\n Optimized method to find the median value of an array of length 5. Parameters ---------- a : float numpy array Input array to find the median. Must be length 5. Returns ------- med5 : float The median of the 5-element array. Notes ----- Wrapper for PyOptMed5 in medutils. """ cdef float * aptr5 = < float * > np.PyArray_DATA(a) cdef float med5 = 0.0 with nogil: med5 = PyOptMed5(aptr5) return med5 def optmed7(np.ndarray[np.float32_t, ndim=1, mode='c', cast=True] a): """optmed7(a)\n Optimized method to find the median value of an array of length 7. Parameters ---------- a : float numpy array Input array to find the median. Must be length 7. Returns ------- med7 : float The median of the 7-element array. Notes ----- Wrapper for PyOptMed7 in medutils. """ cdef float * aptr7 = < float * > np.PyArray_DATA(a) cdef float med7 = 0.0 with nogil: med7 = PyOptMed7(aptr7) return med7 def optmed9(np.ndarray[np.float32_t, ndim=1, mode='c', cast=True] a): """optmed9(a)\n Optimized method to find the median value of an array of length 9. Parameters ---------- a : float numpy array Input array to find the median. Must be length 9. Returns ------- med9 : float The median of the 9-element array. Notes ----- Wrapper for PyOptMed9 in medutils. """ cdef float * aptr9 = < float * > np.PyArray_DATA(a) cdef float med9 = 0.0 with nogil: med9 = PyOptMed9(aptr9) return med9 def optmed25(np.ndarray[np.float32_t, ndim=1, mode='c', cast=True] a): """optmed25(a)\n Optimized method to find the median value of an array of length 25. Parameters ---------- a : float numpy array Input array to find the median. Must be length 25. Returns ------- med25 : float The median of the 25-element array. Notes ----- Wrapper for PyOptMed25 in medutils. """ cdef float * aptr25 = < float * > np.PyArray_DATA(a) cdef float med25 = 0.0 with nogil: med25 = PyOptMed25(aptr25) return med25 def medfilt3(np.ndarray[np.float32_t, ndim=2, mode='c', cast=True] d3): """medfilt3(d3)\n Calculate the 3x3 median filter of an array. Parameters ---------- d3 : float numpy array Array to median filter. Returns ------- output : float numpy array Median filtered array. Notes ----- The median filter is not calculated for a 1 pixel border around the image. These pixel values are copied from the input data. The array needs to be C-contiguous order. Wrapper for PyMedFilt3 in medutils. """ cdef int nx = d3.shape[1] cdef int ny = d3.shape[0] # Allocate the output array here so that Python tracks the memory and will # free the memory when we are finished with the output array. output = np.zeros((ny, nx), dtype=np.float32) cdef float * d3ptr = < float * > np.PyArray_DATA(d3) cdef float * outd3ptr = < float * > np.PyArray_DATA(output) with nogil: PyMedFilt3(d3ptr, outd3ptr, nx, ny) return output def medfilt5(np.ndarray[np.float32_t, ndim=2, mode='c', cast=True] d5): """medfilt5(d5)\n Calculate the 5x5 median filter of an array. Parameters ---------- d5 : float numpy array Array to median filter. Returns ------- output : float numpy array Median filtered array. Notes ----- The median filter is not calculated for a 2 pixel border around the image. These pixel values are copied from the input data. The array needs to be C-contiguous order. Wrapper for PyMedFilt5 in medutils. """ cdef int nx = d5.shape[1] cdef int ny = d5.shape[0] # Allocate the output array here so that Python tracks the memory and will # free the memory when we are finished with the output array. output = np.zeros((ny, nx), dtype=np.float32) cdef float * d5ptr = < float * > np.PyArray_DATA(d5) cdef float * outd5ptr = < float * > np.PyArray_DATA(output) with nogil: PyMedFilt5(d5ptr, outd5ptr, nx, ny) return output def medfilt7(np.ndarray[np.float32_t, ndim=2, mode='c', cast=True] d7): """medfilt7(d7)\n Calculate the 7x7 median filter of an array. Parameters ---------- d7 : float numpy array Array to median filter. Returns ------- output : float numpy array Median filtered array. Notes ----- The median filter is not calculated for a 3 pixel border around the image. These pixel values are copied from the input data. The array needs to be C-contiguous order. Wrapper for PyMedFilt7 in medutils. """ cdef int nx = d7.shape[1] cdef int ny = d7.shape[0] # Allocate the output array here so that Python tracks the memory and will # free the memory when we are finished with the output array. output = np.zeros((ny, nx), dtype=np.float32) cdef float * d7ptr = < float * > np.PyArray_DATA(d7) cdef float * outd7ptr = < float * > np.PyArray_DATA(output) with nogil: PyMedFilt7(d7ptr, outd7ptr, nx, ny) return output def sepmedfilt3(np.ndarray[np.float32_t, ndim=2, mode='c', cast=True] dsep3): """sepmedfilt3(dsep3)\n Calculate the 3x3 separable median filter of an array. Parameters ---------- dsep3 : float numpy array Array to median filter. Returns ------- output : float numpy array Median filtered array. Notes ----- The separable median medians the rows followed by the columns instead of using a square window. Therefore it is not identical to the full median filter but it is approximately the same, but it is significantly faster. The median filter is not calculated for a 1 pixel border around the image. These pixel values are copied from the input data. The array needs to be C-contiguous order. Wrapper for PySepMedFilt3 in medutils. """ cdef int nx = dsep3.shape[1] cdef int ny = dsep3.shape[0] # Allocate the output array here so that Python tracks the memory and will # free the memory when we are finished with the output array. output = np.zeros((ny, nx), dtype=np.float32) cdef float * dsep3ptr = < float * > np.PyArray_DATA(dsep3) cdef float * outdsep3ptr = < float * > np.PyArray_DATA(output) with nogil: PySepMedFilt3(dsep3ptr, outdsep3ptr, nx, ny) return np.asarray(output) def sepmedfilt5(np.ndarray[np.float32_t, ndim=2, mode='c', cast=True] dsep5): """sepmedfilt5(dsep5)\n Calculate the 5x5 separable median filter of an array. Parameters ---------- dsep5 : float numpy array Array to median filter. Returns ------- output : float numpy array Median filtered array. Notes ----- The separable median medians the rows followed by the columns instead of using a square window. Therefore it is not identical to the full median filter but it is approximately the same, but it is significantly faster. The median filter is not calculated for a 2 pixel border around the image. These pixel values are copied from the input data. The array needs to be C-contiguous order. Wrapper for PySepMedFilt5 in medutils. """ cdef int nx = dsep5.shape[1] cdef int ny = dsep5.shape[0] # Allocate the output array here so that Python tracks the memory and will # free the memory when we are finished with the output array. output = np.zeros((ny, nx), dtype=np.float32) cdef float * dsep5ptr = < float * > np.PyArray_DATA(dsep5) cdef float * outdsep5ptr = < float * > np.PyArray_DATA(output) with nogil: PySepMedFilt5(dsep5ptr, outdsep5ptr, nx, ny) return output def sepmedfilt7(np.ndarray[np.float32_t, ndim=2, mode='c', cast=True] dsep7): """sepmedfilt7(dsep7)\n Calculate the 7x7 separable median filter of an array. Parameters ---------- dsep7 : float numpy array Array to median filter. Returns ------- output : float numpy array Median filtered array. Notes ----- The separable median medians the rows followed by the columns instead of using a square window. Therefore it is not identical to the full median filter but it is approximately the same, but it is significantly faster. The median filter is not calculated for a 3 pixel border around the image. These pixel values are copied from the input data. The array needs to be C-contiguous order. Wrapper for PySepMedFilt7 in medutils. """ cdef int nx = dsep7.shape[1] cdef int ny = dsep7.shape[0] # Allocate the output array here so that Python tracks the memory and will # free the memory when we are finished with the output array. output = np.zeros((ny, nx), dtype=np.float32) cdef float * dsep7ptr = < float * > np.PyArray_DATA(dsep7) cdef float * outdsep7ptr = < float * > np.PyArray_DATA(output) with nogil: PySepMedFilt7(dsep7ptr, outdsep7ptr, nx, ny) return output def sepmedfilt9(np.ndarray[np.float32_t, ndim=2, mode='c', cast=True] dsep9): """sepmedfilt9(dsep9)\n Calculate the 9x9 separable median filter of an array. Parameters ---------- dsep9 : float numpy array Array to median filter. Returns ------- output : float numpy array Median filtered array. Notes ----- The separable median medians the rows followed by the columns instead of using a square window. Therefore it is not identical to the full median filter but it is approximately the same, but it is significantly faster. The median filter is not calculated for a 4 pixel border around the image. These pixel values are copied from the input data. The array needs to be C-contiguous order. Wrapper for PySepMedFilt9 in medutils. """ cdef int nx = dsep9.shape[1] cdef int ny = dsep9.shape[0] # Allocate the output array here so that Python tracks the memory and will # free the memory when we are finished with the output array. output = np.zeros((ny, nx), dtype=np.float32) cdef float * dsep9ptr = < float * > np.PyArray_DATA(dsep9) cdef float * outdsep9ptr = < float * > np.PyArray_DATA(output) with nogil: PySepMedFilt9(dsep9ptr, outdsep9ptr, nx, ny) return output ././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1714685814.0 astroscrappy-1.2.0/astroscrappy/utils/medutils.c0000644000175100001770000012514214615003566021550 0ustar00runnerdocker/* * Author: Curtis McCully * October 2014 * Licensed under a 3-clause BSD style license - see LICENSE.rst * * Originally written in C++ in 2011 * See also https://github.com/cmccully/lacosmicx * * This file contains median utility functions for SCRAPPY. These are the most * computationally expensive pieces of the calculation so they have been ported * to C. * * Many thanks to Nicolas Devillard who wrote the optimized methods for finding * the median and placed them in the public domain. I have noted in the * comments places that use Nicolas Devillard's code. * * Parallelization has been achieved using OpenMP. Using a compiler that does * not support OpenMP, e.g. clang currently, the code should still compile and * run serially without issue. I have tried to be explicit as possible about * specifying which variables are private and which should be shared, although * we never actually have any shared variables. We use firstprivate instead. * This does mean that it is important that we never have two threads write to * the same memory position at the same time. * * All calculations are done with 32 bit floats to keep the memory footprint * small. */ #include #include "medutils.h" #define ELEM_SWAP(a,b) { float t=(a);(a)=(b);(b)=t; } float PyMedian(float* a, int n) { /* Get the median of an array "a" with length "n" * using the Quickselect algorithm. Returns a float. * This Quickselect routine is based on the algorithm described in * "Numerical recipes in C", Second Edition, Cambridge University Press, * 1992, Section 8.5, ISBN 0-521-43108-5 * This code by Nicolas Devillard - 1998. Public domain. */ PyDoc_STRVAR(PyMedian__doc__, "PyMedian(a, n) -> float\n\n" "Get the median of array a of length n using the Quickselect " "algorithm."); /* Make a copy of the array so that we don't alter the input array */ float* arr = (float *) malloc(n * sizeof(float)); /* Indices of median, low, and high values we are considering */ int low = 0; int high = n - 1; int median = (low + high) / 2; /* Running indices for the quick select algorithm */ int middle, ll, hh; /* The median to return */ float med; /* running index i */ int i; /* Copy the input data into the array we work with */ for (i = 0; i < n; i++) { arr[i] = a[i]; } /* Start an infinite loop */ while (true) { /* Only One or two elements left */ if (high <= low + 1) { /* Check if we need to swap the two elements */ if ((high == low + 1) && (arr[low] > arr[high])) ELEM_SWAP(arr[low], arr[high]); med = arr[median]; free(arr); return med; } /* Find median of low, middle and high items; * swap into position low */ middle = (low + high) / 2; if (arr[middle] > arr[high]) ELEM_SWAP(arr[middle], arr[high]); if (arr[low] > arr[high]) ELEM_SWAP(arr[low], arr[high]); if (arr[middle] > arr[low]) ELEM_SWAP(arr[middle], arr[low]); /* Swap low item (now in position middle) into position (low+1) */ ELEM_SWAP(arr[middle], arr[low + 1]); /* Nibble from each end towards middle, * swap items when stuck */ ll = low + 1; hh = high; while (true) { do ll++; while (arr[low] > arr[ll]); do hh--; while (arr[hh] > arr[low]); if (hh < ll) break; ELEM_SWAP(arr[ll], arr[hh]); } /* Swap middle item (in position low) back into * the correct position */ ELEM_SWAP(arr[low], arr[hh]); /* Re-set active partition */ if (hh <= median) low = ll; if (hh >= median) high = hh - 1; } } #undef ELEM_SWAP /* All of the optimized median methods below were written by * Nicolas Devillard and are in the public domain. */ #define PIX_SORT(a,b) { if (a>b) PIX_SWAP(a,b); } #define PIX_SWAP(a,b) { float temp=a; a=b; b=temp; } /* ---------------------------------------------------------------------------- Function : PyOptMed3() In : pointer to array of 3 pixel values Out : a pixel value Job : optimized search of the median of 3 pixel values Notice : found on sci.image.processing cannot go faster unless assumptions are made on the nature of the input signal. Code adapted from Nicolas Devillard. --------------------------------------------------------------------------- */ float PyOptMed3(float* p) { PyDoc_STRVAR(PyOptMed3__doc__, "PyOptMed3(a) -> float\n\n" "Get the median of array a of length 3 using a search tree."); PIX_SORT(p[0], p[1]); PIX_SORT(p[1], p[2]); PIX_SORT(p[0], p[1]); return p[1]; } /* ---------------------------------------------------------------------------- Function : PyOptMed5() In : pointer to array of 5 pixel values Out : a pixel value Job : optimized search of the median of 5 pixel values Notice : found on sci.image.processing cannot go faster unless assumptions are made on the nature of the input signal. Code adapted from Nicolas Devillard. --------------------------------------------------------------------------- */ float PyOptMed5(float* p) { PyDoc_STRVAR(PyOptMed5__doc__, "PyOptMed5(a) -> float\n\n" "Get the median of array a of length 5 using a search tree."); PIX_SORT(p[0], p[1]); PIX_SORT(p[3], p[4]); PIX_SORT(p[0], p[3]); PIX_SORT(p[1], p[4]); PIX_SORT(p[1], p[2]); PIX_SORT(p[2], p[3]); PIX_SORT(p[1], p[2]); return p[2]; } /* ---------------------------------------------------------------------------- Function : PyOptMed7() In : pointer to array of 7 pixel values Out : a pixel value Job : optimized search of the median of 7 pixel values Notice : found on sci.image.processing cannot go faster unless assumptions are made on the nature of the input signal. Code adapted from Nicolas Devillard. --------------------------------------------------------------------------- */ float PyOptMed7(float* p) { PyDoc_STRVAR(PyOptMed7__doc__, "PyOptMed7(a) -> float\n\n" "Get the median of array a of length 7 using a search tree."); PIX_SORT(p[0], p[5]); PIX_SORT(p[0], p[3]); PIX_SORT(p[1], p[6]); PIX_SORT(p[2], p[4]); PIX_SORT(p[0], p[1]); PIX_SORT(p[3], p[5]); PIX_SORT(p[2], p[6]); PIX_SORT(p[2], p[3]); PIX_SORT(p[3], p[6]); PIX_SORT(p[4], p[5]); PIX_SORT(p[1], p[4]); PIX_SORT(p[1], p[3]); PIX_SORT(p[3], p[4]); return p[3]; } /* ---------------------------------------------------------------------------- Function : PyOptMed9() In : pointer to an array of 9 pixel values Out : a pixel value Job : optimized search of the median of 9 pixel values Notice : in theory, cannot go faster without assumptions on the signal. Formula from: XILINX XCELL magazine, vol. 23 by John L. Smith The input array is modified in the process The result array is guaranteed to contain the median value in middle position, but other elements are NOT sorted. Code adapted from Nicolas Devillard. --------------------------------------------------------------------------- */ float PyOptMed9(float* p) { PyDoc_STRVAR(PyOptMed9__doc__, "PyOptMed9(a) -> float\n\n" "Get the median of array a of length 9 using a search tree."); PIX_SORT(p[1], p[2]); PIX_SORT(p[4], p[5]); PIX_SORT(p[7], p[8]); PIX_SORT(p[0], p[1]); PIX_SORT(p[3], p[4]); PIX_SORT(p[6], p[7]); PIX_SORT(p[1], p[2]); PIX_SORT(p[4], p[5]); PIX_SORT(p[7], p[8]); PIX_SORT(p[0], p[3]); PIX_SORT(p[5], p[8]); PIX_SORT(p[4], p[7]); PIX_SORT(p[3], p[6]); PIX_SORT(p[1], p[4]); PIX_SORT(p[2], p[5]); PIX_SORT(p[4], p[7]); PIX_SORT(p[4], p[2]); PIX_SORT(p[6], p[4]); PIX_SORT(p[4], p[2]); return p[4]; } /* ---------------------------------------------------------------------------- Function : PyOptMed25() In : pointer to an array of 25 pixel values Out : a pixel value Job : optimized search of the median of 25 pixel values Notice : in theory, cannot go faster without assumptions on the signal. Code taken from Graphic Gems. Code adapted from Nicolas Devillard. --------------------------------------------------------------------------- */ float PyOptMed25(float* p) { PyDoc_STRVAR(PyOptMed25__doc__, "PyOptMed25(a) -> float\n\n" "Get the median of array a of length 25 using a search tree."); PIX_SORT(p[0], p[1]); PIX_SORT(p[3], p[4]); PIX_SORT(p[2], p[4]); PIX_SORT(p[2], p[3]); PIX_SORT(p[6], p[7]); PIX_SORT(p[5], p[7]); PIX_SORT(p[5], p[6]); PIX_SORT(p[9], p[10]); PIX_SORT(p[8], p[10]); PIX_SORT(p[8], p[9]); PIX_SORT(p[12], p[13]); PIX_SORT(p[11], p[13]); PIX_SORT(p[11], p[12]); PIX_SORT(p[15], p[16]); PIX_SORT(p[14], p[16]); PIX_SORT(p[14], p[15]); PIX_SORT(p[18], p[19]); PIX_SORT(p[17], p[19]); PIX_SORT(p[17], p[18]); PIX_SORT(p[21], p[22]); PIX_SORT(p[20], p[22]); PIX_SORT(p[20], p[21]); PIX_SORT(p[23], p[24]); PIX_SORT(p[2], p[5]); PIX_SORT(p[3], p[6]); PIX_SORT(p[0], p[6]); PIX_SORT(p[0], p[3]); PIX_SORT(p[4], p[7]); PIX_SORT(p[1], p[7]); PIX_SORT(p[1], p[4]); PIX_SORT(p[11], p[14]); PIX_SORT(p[8], p[14]); PIX_SORT(p[8], p[11]); PIX_SORT(p[12], p[15]); PIX_SORT(p[9], p[15]); PIX_SORT(p[9], p[12]); PIX_SORT(p[13], p[16]); PIX_SORT(p[10], p[16]); PIX_SORT(p[10], p[13]); PIX_SORT(p[20], p[23]); PIX_SORT(p[17], p[23]); PIX_SORT(p[17], p[20]); PIX_SORT(p[21], p[24]); PIX_SORT(p[18], p[24]); PIX_SORT(p[18], p[21]); PIX_SORT(p[19], p[22]); PIX_SORT(p[8], p[17]); PIX_SORT(p[9], p[18]); PIX_SORT(p[0], p[18]); PIX_SORT(p[0], p[9]); PIX_SORT(p[10], p[19]); PIX_SORT(p[1], p[19]); PIX_SORT(p[1], p[10]); PIX_SORT(p[11], p[20]); PIX_SORT(p[2], p[20]); PIX_SORT(p[2], p[11]); PIX_SORT(p[12], p[21]); PIX_SORT(p[3], p[21]); PIX_SORT(p[3], p[12]); PIX_SORT(p[13], p[22]); PIX_SORT(p[4], p[22]); PIX_SORT(p[4], p[13]); PIX_SORT(p[14], p[23]); PIX_SORT(p[5], p[23]); PIX_SORT(p[5], p[14]); PIX_SORT(p[15], p[24]); PIX_SORT(p[6], p[24]); PIX_SORT(p[6], p[15]); PIX_SORT(p[7], p[16]); PIX_SORT(p[7], p[19]); PIX_SORT(p[13], p[21]); PIX_SORT(p[15], p[23]); PIX_SORT(p[7], p[13]); PIX_SORT(p[7], p[15]); PIX_SORT(p[1], p[9]); PIX_SORT(p[3], p[11]); PIX_SORT(p[5], p[17]); PIX_SORT(p[11], p[17]); PIX_SORT(p[9], p[17]); PIX_SORT(p[4], p[10]); PIX_SORT(p[6], p[12]); PIX_SORT(p[7], p[14]); PIX_SORT(p[4], p[6]); PIX_SORT(p[4], p[7]); PIX_SORT(p[12], p[14]); PIX_SORT(p[10], p[14]); PIX_SORT(p[6], p[7]); PIX_SORT(p[10], p[12]); PIX_SORT(p[6], p[10]); PIX_SORT(p[6], p[17]); PIX_SORT(p[12], p[17]); PIX_SORT(p[7], p[17]); PIX_SORT(p[7], p[10]); PIX_SORT(p[12], p[18]); PIX_SORT(p[7], p[12]); PIX_SORT(p[10], p[18]); PIX_SORT(p[12], p[20]); PIX_SORT(p[10], p[20]); PIX_SORT(p[10], p[12]); return p[12]; } #undef PIX_SORT #undef PIX_SWAP /* We have slightly unusual boundary conditions for all of the median filters * below. Rather than padding the data, we just don't calculate the median * filter for pixels around the border of the output image (n - 1) / 2 from * the edge, where we are using an n x n median filter. Edge effects often * look like cosmic rays and the edges are often blank so this shouldn't * matter. We fill the border with the original data values. */ /* Calculate the 3x3 median filter of an array data that has dimensions * nx x ny. The results are saved in the output array. The output array should * already be allocated as we work on it in place. The median filter is not * calculated for a 1 pixel border around the image. These pixel values are * copied from the input data. The data should be striped along the x * direction, such that pixel i,j in the 2D image should have memory location * data[i + nx *j]. */ void PyMedFilt3(float* data, float* output, int nx, int ny) { PyDoc_STRVAR(PyMedFilt3__doc__, "PyMedFilt3(data, output, nx, ny) -> void\n\n" "Calculate the 3x3 median filter on an array data with dimensions " "nx x ny. The results are saved in the output array. The output " "array should already be allocated as we work on it in place. The " "median filter is not calculated for a 1 pixel border around the " "image. These pixel values are copied from the input data. Note " "that the data array needs to be striped in the x direction such " "that pixel i,j has memory location data[i + nx * j]"); /*Total size of the array */ int nxny = nx * ny; /* Loop indices */ int i, j, nxj; int k, l, nxk; /* 9 element array to calculate the median and a counter index. Note that * these both need to be unique for each thread so they both need to be * private and we wait to allocate memory until the pragma below.*/ float* medarr; int medcounter; /* Each thread needs to access the data and the output so we make them * firstprivate. We make sure that our algorithm doesn't have multiple * threads read or write the same piece of memory. */ #pragma omp parallel firstprivate(output, data, nx, ny) \ private(i, j, k, l, medarr, nxj, nxk, medcounter) { /*Each thread allocates its own array. */ medarr = (float *) malloc(9 * sizeof(float)); /* Go through each pixel excluding the border.*/ #pragma omp for nowait for (j = 1; j < ny - 1; j++) { /* Precalculate the multiplication nx * j, minor optimization */ nxj = nx * j; for (i = 1; i < nx - 1; i++) { medcounter = 0; /* The compiler should optimize away these loops */ for (k = -1; k < 2; k++) { nxk = nx * k; for (l = -1; l < 2; l++) { medarr[medcounter] = data[nxj + i + nxk + l]; medcounter++; } } /* Calculate the median in the fastest way possible */ output[nxj + i] = PyOptMed9(medarr); } } /* Each thread needs to free its own copy of medarr */ free(medarr); } #pragma omp parallel firstprivate(output, data, nx, nxny) private(i) /* Copy the border pixels from the original data into the output array */ for (i = 0; i < nx; i++) { output[i] = data[i]; output[nxny - nx + i] = data[nxny - nx + i]; } #pragma omp parallel firstprivate(output, data, nx, ny) private(j, nxj) for (j = 0; j < ny; j++) { nxj = nx * j; output[nxj] = data[nxj]; output[nxj + nx - 1] = data[nxj + nx - 1]; } return; } /* Calculate the 5x5 median filter of an array data that has dimensions * nx x ny. The results are saved in the output array. The output array should * already be allocated as we work on it in place. The median filter is not * calculated for a 2 pixel border around the image. These pixel values are * copied from the input data. The data should be striped along the * x direction, such that pixel i,j in the 2D image should have memory * location data[i + nx *j]. */ void PyMedFilt5(float* data, float* output, int nx, int ny) { PyDoc_STRVAR(PyMedFilt5__doc__, "PyMedFilt5(data, output, nx, ny) -> void\n\n" "Calculate the 5x5 median filter on an array data with dimensions " "nx x ny. The results are saved in the output array. The output " "array should already be allocated as we work on it in place. The " "median filter is not calculated for a 2 pixel border around the " "image. These pixel values are copied from the input data. Note " "that the data array needs to be striped in the x direction such " "that pixel i,j has memory location data[i + nx * j]"); /*Total size of the array */ int nxny = nx * ny; /* Loop indices */ int i, j, nxj; int k, l, nxk; /* 25 element array to calculate the median and a counter index. Note that * these both need to be unique for each thread so they both need to be * private and we wait to allocate memory until the pragma below. */ float* medarr; int medcounter; /* Each thread needs to access the data and the output so we make them * firstprivate. We make sure that our algorithm doesn't have multiple * threads read or write the same piece of memory. */ #pragma omp parallel firstprivate(output, data, nx, ny) \ private(i, j, k, l, medarr, nxj, nxk, medcounter) { /*Each thread allocates its own array. */ medarr = (float *) malloc(25 * sizeof(float)); /* Go through each pixel excluding the border.*/ #pragma omp for nowait for (j = 2; j < ny - 2; j++) { /* Precalculate the multiplication nx * j, minor optimization */ nxj = nx * j; for (i = 2; i < nx - 2; i++) { medcounter = 0; /* The compiler should optimize away these loops */ for (k = -2; k < 3; k++) { nxk = nx * k; for (l = -2; l < 3; l++) { medarr[medcounter] = data[nxj + i + nxk + l]; medcounter++; } } /* Calculate the median in the fastest way possible */ output[nxj + i] = PyOptMed25(medarr); } } /* Each thread needs to free its own copy of medarr */ free(medarr); } #pragma omp parallel firstprivate(output, data, nx, nxny) private(i) /* Copy the border pixels from the original data into the output array */ for (i = 0; i < nx; i++) { output[i] = data[i]; output[i + nx] = data[i + nx]; output[nxny - nx + i] = data[nxny - nx + i]; output[nxny - nx - nx + i] = data[nxny - nx - nx + i]; } #pragma omp parallel firstprivate(output, data, nx, ny) private(j, nxj) for (j = 0; j < ny; j++) { nxj = nx * j; output[nxj] = data[nxj]; output[nxj + 1] = data[nxj + 1]; output[nxj + nx - 1] = data[nxj + nx - 1]; output[nxj + nx - 2] = data[nxj + nx - 2]; } return; } /* Calculate the 7x7 median filter of an array data that has dimensions * nx x ny. The results are saved in the output array. The output array should * already be allocated as we work on it in place. The median filter is not * calculated for a 3 pixel border around the image. These pixel values are * copied from the input data. The data should be striped along the * x direction, such that pixel i,j in the 2D image should have memory * location data[i + nx *j]. */ void PyMedFilt7(float* data, float* output, int nx, int ny) { PyDoc_STRVAR(PyMedFilt7__doc__, "PyMedFilt7(data, output, nx, ny) -> void\n\n" "Calculate the 7x7 median filter on an array data with dimensions " "nx x ny. The results are saved in the output array. The output " "array should already be allocated as we work on it in place. The " "median filter is not calculated for a 3 pixel border around the " "image. These pixel values are copied from the input data. Note " "that the data array needs to be striped in the x direction such " "that pixel i,j has memory location data[i + nx * j]"); /*Total size of the array */ int nxny = nx * ny; /* Loop indices */ int i, j, nxj; int k, l, nxk; /* 49 element array to calculate the median and a counter index. Note that * these both need to be unique for each thread so they both need to be * private and we wait to allocate memory until the pragma below. */ float* medarr; int medcounter; /* Each thread needs to access the data and the output so we make them * firstprivate. We make sure that our algorithm doesn't have multiple * threads read or write the same piece of memory. */ #pragma omp parallel firstprivate(output, data, nx, ny) \ private(i, j, k, l, medarr, nxj, nxk, medcounter) { /*Each thread allocates its own array. */ medarr = (float *) malloc(49 * sizeof(float)); /* Go through each pixel excluding the border.*/ #pragma omp for nowait for (j = 3; j < ny - 3; j++) { /* Precalculate the multiplication nx * j, minor optimization */ nxj = nx * j; for (i = 3; i < nx - 3; i++) { medcounter = 0; /* The compiler should optimize away these loops */ for (k = -3; k < 4; k++) { nxk = nx * k; for (l = -3; l < 4; l++) { medarr[medcounter] = data[nxj + i + nxk + l]; medcounter++; } } /* Calculate the median in the fastest way possible */ output[nxj + i] = PyMedian(medarr, 49); } } /* Each thread needs to free its own copy of medarr */ free(medarr); } #pragma omp parallel firstprivate(output, data, nx, nxny) private(i) /* Copy the border pixels from the original data into the output array */ for (i = 0; i < nx; i++) { output[i] = data[i]; output[i + nx] = data[i + nx]; output[i + nx + nx] = data[i + nx + nx]; output[nxny - nx + i] = data[nxny - nx + i]; output[nxny - nx - nx + i] = data[nxny - nx - nx + i]; output[nxny - nx - nx - nx + i] = data[nxny - nx - nx - nx + i]; } #pragma omp parallel firstprivate(output, data, nx, ny) private(j, nxj) for (j = 0; j < ny; j++) { nxj = nx * j; output[nxj] = data[nxj]; output[nxj + 1] = data[nxj + 1]; output[nxj + 2] = data[nxj + 2]; output[nxj + nx - 1] = data[nxj + nx - 1]; output[nxj + nx - 2] = data[nxj + nx - 2]; output[nxj + nx - 3] = data[nxj + nx - 3]; } return; } /* Calculate the 3x3 separable median filter of an array data that has * dimensions nx x ny. The results are saved in the output array. The output * array should already be allocated as we work on it in place. The median * filter is not calculated for a 1 pixel border around the image. These pixel * values are copied from the input data. The data should be striped along * the x direction, such that pixel i,j in the 2D image should have memory * location data[i + nx *j]. Note that the rows are median filtered first, * followed by the columns. */ void PySepMedFilt3(float* data, float* output, int nx, int ny) { PyDoc_STRVAR(PySepMedFilt3__doc__, "PySepMedFilt3(data, output, nx, ny) -> void\n\n" "Calculate the 3x3 separable median filter on an array data with" "dimensions nx x ny. The results are saved in the output array " "which should already be allocated as we work on it in place. The " "median filter is not calculated for a 1 pixel border which is " "copied from the input data. The data array should be striped in " "the x direction such that pixel i,j has memory location " "data[i + nx * j]. Note that the rows are median filtered first, " "followed by the columns."); /* Total number of pixels */ int nxny = nx * ny; /* Output array for the median filter of the rows. We later median filter * the columns of this array. */ float* rowmed = (float *) malloc(nxny * sizeof(float)); /* Loop indices */ int i, j, nxj; /* 3 element array to calculate the median and a counter index. Note that * this array needs to be unique for each thread so it needs to be * private and we wait to allocate memory until the pragma below. */ float* medarr; /* Median filter the rows first */ /* Each thread needs to access the data and rowmed so we make them * firstprivate. We make sure that our algorithm doesn't have multiple * threads read or write the same piece of memory. */ #pragma omp parallel firstprivate(data, rowmed, nx, ny) \ private(i, j, nxj, medarr) { /*Each thread allocates its own array. */ medarr = (float *) malloc(3 * sizeof(float)); /* For each pixel excluding the border */ #pragma omp for nowait for (j = 0; j < ny; j++) { nxj = nx * j; for (i = 1; i < nx - 1; i++) { medarr[0] = data[nxj + i]; medarr[1] = data[nxj + i - 1]; medarr[2] = data[nxj + i + 1]; /* Calculate the median in the fastest way possible */ rowmed[nxj + i] = PyOptMed3(medarr); } } /* Each thread needs to free its own medarr */ free(medarr); } /* Fill in the borders of rowmed with the original data values */ #pragma omp parallel for firstprivate(data, rowmed, nx, ny) private(j, nxj) for (j = 0; j < ny; j++) { nxj = nx * j; rowmed[nxj] = data[nxj]; rowmed[nxj + nx - 1] = data[nxj + nx - 1]; } /* Median filter the columns */ #pragma omp parallel firstprivate(rowmed, output, nx, ny) \ private(i, j, nxj, medarr) { /* Each thread needs to reallocate a new medarr */ medarr = (float *) malloc(3 * sizeof(float)); /* For each pixel excluding the border */ #pragma omp for nowait for (j = 1; j < ny - 1; j++) { nxj = nx * j; for (i = 1; i < nx - 1; i++) { medarr[0] = rowmed[i + nxj]; medarr[1] = rowmed[i + nxj - nx]; medarr[2] = rowmed[i + nxj + nx]; /* Calculate the median in the fastest way possible */ output[nxj + i] = PyOptMed3(medarr); } } /* Each thread needs to free its own medarr */ free(medarr); } /* Clean up rowmed */ free(rowmed); /* Copy the border pixels from the original data into the output array */ #pragma omp parallel for firstprivate(output, data, nx, nxny) private(i) for (i = 0; i < nx; i++) { output[i] = data[i]; output[nxny - nx + i] = data[nxny - nx + i]; } #pragma omp parallel for firstprivate(output, data, nx, ny) private(j, nxj) for (j = 0; j < ny; j++) { nxj = nx * j; output[nxj] = data[nxj]; output[nxj + nx - 1] = data[nxj + nx - 1]; } return; } /* Calculate the 5x5 separable median filter of an array data that has * dimensions nx x ny. The results are saved in the output array. The output * array should already be allocated as we work on it in place.The median * filter is not calculated for a 2 pixel border around the image. These pixel * values are copied from the input data. The data should be striped along the * x direction, such that pixel i,j in the 2D image should have memory location * data[i + nx *j]. Note that the rows are median filtered first, followed by * the columns. */ void PySepMedFilt5(float* data, float* output, int nx, int ny) { PyDoc_STRVAR(PySepMedFilt5__doc__, "PySepMedFilt5(data, output, nx, ny) -> void\n\n" "Calculate the 5x5 separable median filter on an array data with " "dimensions nx x ny. The results are saved in the output array " "which should already be allocated as we work on it in place. The " "median filter is not calculated for a 2 pixel border which is " "copied from the input data. The data array should be striped in " "the x direction such that pixel i,j has memory location " "data[i + nx * j]. Note that the rows are median filtered first, " "followed by the columns."); /* Total number of pixels */ int nxny = nx * ny; /* Output array for the median filter of the rows. We later median filter * the columns of this array. */ float* rowmed = (float *) malloc(nxny * sizeof(float)); /* Loop indices */ int i, j, nxj; /* 5 element array to calculate the median and a counter index. Note that * this array needs to be unique for each thread so it needs to be * private and we wait to allocate memory until the pragma below. */ float* medarr; /* Median filter the rows first */ /* Each thread needs to access the data and rowmed so we make them * firstprivate. We make sure that our algorithm doesn't have multiple * threads read or write the same piece of memory. */ #pragma omp parallel firstprivate(data, rowmed, nx, ny) \ private(i, j, nxj, medarr) { /*Each thread allocates its own array. */ medarr = (float *) malloc(5 * sizeof(float)); /* For each pixel excluding the border */ #pragma omp for nowait for (j = 0; j < ny; j++) { nxj = nx * j; for (i = 2; i < nx - 2; i++) { medarr[0] = data[nxj + i]; medarr[1] = data[nxj + i - 1]; medarr[2] = data[nxj + i + 1]; medarr[3] = data[nxj + i - 2]; medarr[4] = data[nxj + i + 2]; /* Calculate the median in the fastest way possible */ rowmed[nxj + i] = PyOptMed5(medarr); } } /* Each thread needs to free its own medarr */ free(medarr); } /* Fill in the borders of rowmed with the original data values */ #pragma omp parallel for firstprivate(rowmed, data, nx, ny) private(j, nxj) for (j = 0; j < ny; j++) { nxj = nx * j; rowmed[nxj] = data[nxj]; rowmed[nxj + 1] = data[nxj + 1]; rowmed[nxj + nx - 1] = data[nxj + nx - 1]; rowmed[nxj + nx - 2] = data[nxj + nx - 2]; } /* Median filter the columns */ #pragma omp parallel firstprivate(rowmed, output, nx, ny) \ private(i, j, nxj, medarr) { /* Each thread needs to reallocate a new medarr */ medarr = (float *) malloc(5 * sizeof(float)); /* For each pixel excluding the border */ #pragma omp for nowait for (j = 2; j < ny - 2; j++) { nxj = nx * j; for (i = 2; i < nx - 2; i++) { medarr[0] = rowmed[i + nxj]; medarr[1] = rowmed[i + nxj - nx]; medarr[2] = rowmed[i + nxj + nx]; medarr[3] = rowmed[i + nxj + nx + nx]; medarr[4] = rowmed[i + nxj - nx - nx]; /* Calculate the median in the fastest way possible */ output[nxj + i] = PyOptMed5(medarr); } } /* Each thread needs to free its own medarr */ free(medarr); } /* Clean up rowmed */ free(rowmed); /* Copy the border pixels from the original data into the output array */ #pragma omp parallel for firstprivate(output, data, nx, nxny) private(i) for (i = 0; i < nx; i++) { output[i] = data[i]; output[i + nx] = data[i + nx]; output[nxny - nx + i] = data[nxny - nx + i]; output[nxny - nx - nx + i] = data[nxny - nx - nx + i]; } #pragma omp parallel for firstprivate(output, data, nx, ny) private(j, nxj) for (j = 0; j < ny; j++) { nxj = nx * j; output[nxj] = data[nxj]; output[nxj + 1] = data[nxj + 1]; output[nxj + nx - 1] = data[nxj + nx - 1]; output[nxj + nx - 2] = data[nxj + nx - 2]; } return; } /* Calculate the 7x7 separable median filter of an array data that has * dimensions nx x ny. The results are saved in the output array. The output * array should already be allocated as we work on it in place. The median * filter is not calculated for a 3 pixel border around the image. These pixel * values are copied from the input data. The data should be striped along the * x direction, such that pixel i,j in the 2D image should have memory location * data[i + nx *j]. Note that the rows are median filtered first, followed by * the columns. */ void PySepMedFilt7(float* data, float* output, int nx, int ny) { PyDoc_STRVAR(PySepMedFilt7__doc__, "PySepMedFilt7(data, output, nx, ny) -> void\n\n" "Calculate the 7x7 separable median filter on an array data with " "dimensions nx x ny. The results are saved in the output array " "which should already be allocated as we work on it in place. The " "median filter is not calculated for a 3 pixel border which is " "copied from the input data. The data array should be striped in " "the x direction such that pixel i,j has memory location " "data[i + nx * j]. Note that the rows are median filtered first, " "followed by the columns."); /* Total number of pixels */ int nxny = nx * ny; /* Output array for the median filter of the rows. We later median filter * the columns of this array. */ float* rowmed = (float *) malloc(nxny * sizeof(float)); /* Loop indices */ int i, j, nxj; /* 7 element array to calculate the median and a counter index. Note that * this array needs to be unique for each thread so it needs to be * private and we wait to allocate memory until the pragma below. */ float* medarr; /* Median filter the rows first */ /* Each thread needs to access the data and rowmed so we make them * firstprivate. We make sure that our algorithm doesn't have multiple * threads read or write the same piece of memory. */ #pragma omp parallel firstprivate(data, rowmed, nx, ny) \ private(i, j, nxj, medarr) { /*Each thread allocates its own array. */ medarr = (float *) malloc(7 * sizeof(float)); /* For each pixel excluding the border */ #pragma omp for nowait for (j = 0; j < ny; j++) { nxj = nx * j; for (i = 3; i < nx - 3; i++) { medarr[0] = data[nxj + i]; medarr[1] = data[nxj + i - 1]; medarr[2] = data[nxj + i + 1]; medarr[3] = data[nxj + i - 2]; medarr[4] = data[nxj + i + 2]; medarr[5] = data[nxj + i - 3]; medarr[6] = data[nxj + i + 3]; /* Calculate the median in the fastest way possible */ rowmed[nxj + i] = PyOptMed7(medarr); } } /* Each thread needs to free its own medarr */ free(medarr); } /* Fill in the borders of rowmed with the original data values */ #pragma omp parallel for firstprivate(rowmed, data, nx, ny) private(j, nxj) for (j = 0; j < ny; j++) { nxj = nx * j; rowmed[nxj] = data[nxj]; rowmed[nxj + 1] = data[nxj + 1]; rowmed[nxj + 2] = data[nxj + 2]; rowmed[nxj + nx - 1] = data[nxj + nx - 1]; rowmed[nxj + nx - 2] = data[nxj + nx - 2]; rowmed[nxj + nx - 3] = data[nxj + nx - 3]; } /* Median filter the columns */ #pragma omp parallel firstprivate(rowmed, output, nx, ny) \ private(i, j, nxj, medarr) { /* Each thread needs to reallocate a new medarr */ medarr = (float *) malloc(7 * sizeof(float)); /* For each pixel excluding the border */ #pragma omp for nowait for (j = 3; j < ny - 3; j++) { nxj = nx * j; for (i = 3; i < nx - 3; i++) { medarr[0] = rowmed[i + nxj - nx]; medarr[1] = rowmed[i + nxj + nx]; medarr[2] = rowmed[i + nxj + nx + nx]; medarr[3] = rowmed[i + nxj - nx - nx]; medarr[4] = rowmed[i + nxj]; medarr[5] = rowmed[i + nxj + nx + nx + nx]; medarr[6] = rowmed[i + nxj - nx - nx - nx]; /* Calculate the median in the fastest way possible */ output[nxj + i] = PyOptMed7(medarr); } } /* Each thread needs to free its own medarr */ free(medarr); } /* Clean up rowmed */ free(rowmed); /* Copy the border pixels from the original data into the output array */ #pragma omp parallel for firstprivate(output, data, nx, nxny) private(i) for (i = 0; i < nx; i++) { output[i] = data[i]; output[i + nx] = data[i + nx]; output[i + nx + nx] = data[i + nx + nx]; output[nxny - nx + i] = data[nxny - nx + i]; output[nxny - nx - nx + i] = data[nxny - nx - nx + i]; output[nxny - nx - nx - nx + i] = data[nxny - nx - nx - nx + i]; } #pragma omp parallel for firstprivate(output, data, nx, ny) private(j, nxj) for (j = 0; j < ny; j++) { nxj = nx * j; output[nxj] = data[nxj]; output[nxj + 1] = data[nxj + 1]; output[nxj + 2] = data[nxj + 2]; output[nxj + nx - 1] = data[nxj + nx - 1]; output[nxj + nx - 2] = data[nxj + nx - 2]; output[nxj + nx - 3] = data[nxj + nx - 3]; } return; } /* Calculate the 9x9 separable median filter of an array data that has * dimensions nx x ny. The results are saved in the output array. The output * array should already be allocated as we work on it in place. The median * filter is not calculated for a 4 pixel border around the image. These pixel * values are copied from the input data. The data should be striped along the * x direction, such that pixel i,j in the 2D image should have memory location * data[i + nx *j]. Note that the rows are median filtered first, followed by * the columns. */ void PySepMedFilt9(float* data, float* output, int nx, int ny) { PyDoc_STRVAR(PySepMedFilt9__doc__, "PySepMedFilt9(data, output, nx, ny) -> void\n\n" "Calculate the 9x9 separable median filter on an array data with " "dimensions nx x ny. The results are saved in the output array " "which should already be allocated as we work on it in place. The " "median filter is not calculated for a 4 pixel border which is " "copied from the input data. The data array should be striped in " "the x direction such that pixel i,j has memory location " "data[i + nx * j]. Note that the rows are median filtered first, " "followed by the columns."); /* Total number of pixels */ int nxny = nx * ny; /* Output array for the median filter of the rows. We later median filter * the columns of this array. */ float* rowmed = (float *) malloc(nxny * sizeof(float)); /* Loop indices */ int i, j, nxj; /* 9 element array to calculate the median and a counter index. Note that * this array needs to be unique for each thread so it needs to be * private and we wait to allocate memory until the pragma below. */ float* medarr; /* Median filter the rows first */ /* Each thread needs to access the data and rowmed so we make them * firstprivate. We make sure that our algorithm doesn't have multiple * threads read or write the same piece of memory. */ #pragma omp parallel firstprivate(data, rowmed, nx, ny) \ private(i, j, nxj, medarr) { /*Each thread allocates its own array. */ medarr = (float *) malloc(9 * sizeof(float)); /* For each pixel excluding the border */ #pragma omp for nowait for (j = 0; j < ny; j++) { nxj = nx * j; for (i = 4; i < nx - 4; i++) { medarr[0] = data[nxj + i]; medarr[1] = data[nxj + i - 1]; medarr[2] = data[nxj + i + 1]; medarr[3] = data[nxj + i - 2]; medarr[4] = data[nxj + i + 2]; medarr[5] = data[nxj + i - 3]; medarr[6] = data[nxj + i + 3]; medarr[7] = data[nxj + i - 4]; medarr[8] = data[nxj + i + 4]; /* Calculate the median in the fastest way possible */ rowmed[nxj + i] = PyOptMed9(medarr); } } /* Each thread needs to free its own medarr */ free(medarr); } /* Fill in the borders of rowmed with the original data values */ #pragma omp parallel for firstprivate(rowmed, data, nx, ny) private(j, nxj) for (j = 0; j < ny; j++) { nxj = nx * j; rowmed[nxj] = data[nxj]; rowmed[nxj + 1] = data[nxj + 1]; rowmed[nxj + 2] = data[nxj + 2]; rowmed[nxj + 3] = data[nxj + 3]; rowmed[nxj + nx - 1] = data[nxj + nx - 1]; rowmed[nxj + nx - 2] = data[nxj + nx - 2]; rowmed[nxj + nx - 3] = data[nxj + nx - 3]; rowmed[nxj + nx - 4] = data[nxj + nx - 4]; } /* Median filter the columns */ #pragma omp parallel firstprivate(rowmed, output, nx, ny) \ private(i, j, nxj, medarr) { /* Each thread needs to reallocate a new medarr */ medarr = (float *) malloc(9 * sizeof(float)); /* For each pixel excluding the border */ #pragma omp for nowait for (j = 4; j < ny - 4; j++) { nxj = nx * j; for (i = 4; i < nx - 4; i++) { medarr[0] = rowmed[i + nxj]; medarr[1] = rowmed[i + nxj - nx]; medarr[2] = rowmed[i + nxj + nx]; medarr[3] = rowmed[i + nxj + nx + nx]; medarr[4] = rowmed[i + nxj - nx - nx]; medarr[5] = rowmed[i + nxj + nx + nx + nx]; medarr[6] = rowmed[i + nxj - nx - nx - nx]; medarr[7] = rowmed[i + nxj + nx + nx + nx + nx]; medarr[8] = rowmed[i + nxj - nx - nx - nx - nx]; /* Calculate the median in the fastest way possible */ output[nxj + i] = PyOptMed9(medarr); } } /* Each thread needs to free its own medarr */ free(medarr); } /* Clean up rowmed */ free(rowmed); /* Copy the border pixels from the original data into the output array */ #pragma omp parallel for firstprivate(output, data, nx, nxny) private(i) for (i = 0; i < nx; i++) { output[i] = data[i]; output[i + nx] = data[i + nx]; output[i + nx + nx] = data[i + nx + nx]; output[i + nx + nx + nx] = data[i + nx + nx + nx]; output[nxny - nx + i] = data[nxny - nx + i]; output[nxny - nx - nx + i] = data[nxny - nx - nx + i]; output[nxny - nx - nx - nx + i] = data[nxny - nx - nx - nx + i]; output[nxny - nx - nx - nx - nx + i] = data[nxny - nx - nx - nx - nx + i]; } #pragma omp parallel for firstprivate(output, data, nx, ny) private(j, nxj) for (j = 0; j < ny; j++) { nxj = nx * j; output[nxj] = data[nxj]; output[nxj + 1] = data[nxj + 1]; output[nxj + 2] = data[nxj + 2]; output[nxj + 3] = data[nxj + 3]; output[nxj + nx - 1] = data[nxj + nx - 1]; output[nxj + nx - 2] = data[nxj + nx - 2]; output[nxj + nx - 3] = data[nxj + nx - 3]; output[nxj + nx - 4] = data[nxj + nx - 4]; } return; } ././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1714685814.0 astroscrappy-1.2.0/astroscrappy/utils/medutils.h0000644000175100001770000001207714615003566021557 0ustar00runnerdocker/* * medutils.h * * Author: Curtis McCully * October 2014 * * Licensed under a 3-clause BSD style license - see LICENSE.rst */ #ifndef MEDUTILS_H_ #define MEDUTILS_H_ /* Including definitions of the standard int types is necesssary for Windows, * and does no harm on other platforms. */ #include /* Define a bool type because there isn't one built in ANSI C */ typedef uint8_t bool; #define true 1 #define false 0 /*Find the median value of an array "a" of length n. */ float PyMedian(float* a, int n); /*Optimized method to find the median value of an array "a" of length 3. */ float PyOptMed3(float* a); /*Optimized method to find the median value of an array "a" of length 5. */ float PyOptMed5(float* a); /*Optimized method to find the median value of an array "a" of length 7. */ float PyOptMed7(float* a); /*Optimized method to find the median value of an array "a" of length 9. */ float PyOptMed9(float* a); /*Optimized method to find the median value of an array "a" of length 25. */ float PyOptMed25(float* a); /* Calculate the 3x3 median filter of an array data that has dimensions * nx x ny. The results are saved in the output array. The output array should * already be allocated as we work on it in place. The median filter is not * calculated for a 1 pixel border around the image. These pixel values are * copied from the input data. The data should be striped along the x * direction, such that pixel i,j in the 2D image should have memory location * data[i + nx *j]. */ void PyMedFilt3(float* data, float* output, int nx, int ny); /* Calculate the 5x5 median filter of an array data that has dimensions * nx x ny. The results are saved in the output array. The output array should * already be allocated as we work on it in place. The median filter is not * calculated for a 2 pixel border around the image. These pixel values are * copied from the input data. The data should be striped along the * x direction, such that pixel i,j in the 2D image should have memory * location data[i + nx *j]. */ void PyMedFilt5(float* data, float* output, int nx, int ny); /* Calculate the 7x7 median filter of an array data that has dimensions * nx x ny. The results are saved in the output array. The output array should * already be allocated as we work on it in place. The median filter is not * calculated for a 3 pixel border around the image. These pixel values are * copied from the input data. The data should be striped along the * x direction, such that pixel i,j in the 2D image should have memory * location data[i + nx *j]. */ void PyMedFilt7(float* data, float* output, int nx, int ny); /* Calculate the 3x3 separable median filter of an array data that has * dimensions nx x ny. The results are saved in the output array. The output * array should already be allocated as we work on it in place. The median * filter is not calculated for a 1 pixel border around the image. These pixel * values are copied from the input data. The data should be striped along * the x direction, such that pixel i,j in the 2D image should have memory * location data[i + nx *j]. Note that the rows are median filtered first, * followed by the columns. */ void PySepMedFilt3(float* data, float* output, int nx, int ny); /* Calculate the 5x5 separable median filter of an array data that has * dimensions nx x ny. The results are saved in the output array. The output * array should already be allocated as we work on it in place.The median * filter is not calculated for a 2 pixel border around the image. These pixel * values are copied from the input data. The data should be striped along the * x direction, such that pixel i,j in the 2D image should have memory location * data[i + nx *j]. Note that the rows are median filtered first, followed by * the columns. */ void PySepMedFilt5(float* data, float* output, int nx, int ny); /* Calculate the 7x7 separable median filter of an array data that has * dimensions nx x ny. The results are saved in the output array. The output * array should already be allocated as we work on it in place. The median * filter is not calculated for a 3 pixel border around the image. These pixel * values are copied from the input data. The data should be striped along the * x direction, such that pixel i,j in the 2D image should have memory location * data[i + nx *j]. Note that the rows are median filtered first, followed by * the columns. */ void PySepMedFilt7(float* data, float* output, int nx, int ny); /* Calculate the 9x9 separable median filter of an array data that has * dimensions nx x ny. The results are saved in the output array. The output * array should already be allocated as we work on it in place. The median * filter is not calculated for a 4 pixel border around the image. These pixel * values are copied from the input data. The data should be striped along the * x direction, such that pixel i,j in the 2D image should have memory location * data[i + nx *j]. Note that the rows are median filtered first, followed by * the columns. */ void PySepMedFilt9(float* data, float* output, int nx, int ny); #endif /* MEDUTILS_H_ */ ././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1714685814.0 astroscrappy-1.2.0/astroscrappy/utils/setup_package.py0000644000175100001770000000257114615003566022743 0ustar00runnerdockerimport os import numpy as np from setuptools import Extension from extension_helpers import add_openmp_flags_if_available UTIL_DIR = os.path.relpath(os.path.dirname(__file__)) def get_extensions(): med_sources = [os.path.join(UTIL_DIR, "median_utils.pyx"), os.path.join(UTIL_DIR, "medutils.c")] im_sources = [os.path.join(UTIL_DIR, "image_utils.pyx"), os.path.join(UTIL_DIR, "imutils.c")] include_dirs = [np.get_include(), UTIL_DIR] if 'CFLAGS' in os.environ: extra_compile_args = os.environ['CFLAGS'].split() else: extra_compile_args = ['-g', '-O3', '-funroll-loops', '-ffast-math'] ext_med = Extension(name='astroscrappy.utils.median_utils', define_macros=[("NPY_NO_DEPRECATED_API", "NPY_1_7_API_VERSION")], sources=med_sources, include_dirs=include_dirs, extra_compile_args=extra_compile_args) ext_im = Extension(name="astroscrappy.utils.image_utils", define_macros=[("NPY_NO_DEPRECATED_API", "NPY_1_7_API_VERSION")], sources=im_sources, include_dirs=include_dirs, extra_compile_args=extra_compile_args) add_openmp_flags_if_available(ext_med) add_openmp_flags_if_available(ext_im) return [ext_med, ext_im] ././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1714685833.0 astroscrappy-1.2.0/astroscrappy/version.py0000644000175100001770000000063314615003611020441 0ustar00runnerdocker# file generated by setuptools_scm # don't change, don't track in version control TYPE_CHECKING = False if TYPE_CHECKING: from typing import Tuple, Union VERSION_TUPLE = Tuple[Union[int, str], ...] else: VERSION_TUPLE = object version: str __version__: str __version_tuple__: VERSION_TUPLE version_tuple: VERSION_TUPLE __version__ = version = '1.2.0' __version_tuple__ = version_tuple = (1, 2, 0) ././@PaxHeader0000000000000000000000000000003400000000000010212 xustar0028 mtime=1714685833.3694384 astroscrappy-1.2.0/astroscrappy.egg-info/0000755000175100001770000000000014615003611020072 5ustar00runnerdocker././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1714685833.0 astroscrappy-1.2.0/astroscrappy.egg-info/PKG-INFO0000644000175100001770000000700714615003611021173 0ustar00runnerdockerMetadata-Version: 2.1 Name: astroscrappy Version: 1.2.0 Summary: Speedy Cosmic Ray Annihilation Package in Python Author-email: Curtis McCully License: BSD-3-Clause Project-URL: Homepage, https://github.com/astropy/astroscrappy Requires-Python: >=3.9 Description-Content-Type: text/x-rst License-File: licenses/LICENSE.rst Requires-Dist: astropy Requires-Dist: numpy Provides-Extra: docs Requires-Dist: sphinx-astropy; extra == "docs" Provides-Extra: test Requires-Dist: Cython; extra == "test" Requires-Dist: pytest-astropy; extra == "test" Requires-Dist: scipy; extra == "test" Astro-SCRAPPY: The Speedy Cosmic Ray Annihilation Package in Python =================================================================== .. image:: https://readthedocs.org/projects/astroscrappy/badge/?version=latest :alt: Documentation Status :scale: 100% :target: https://astroscrappy.readthedocs.io/en/latest/?badge=latest .. image:: https://github.com/astropy/astroscrappy/workflows/Run%20unit%20tests/badge.svg :target: https://github.com/astropy/astroscrappy/actions :alt: CI Status .. image:: https://codecov.io/gh/astropy/astroscrappy/branch/main/graph/badge.svg :target: https://codecov.io/gh/astropy/astroscrappy :alt: AstroScrappy's Coverage Status .. image:: https://zenodo.org/badge/36837126.svg :target: https://zenodo.org/badge/latestdoi/36837126 An optimized cosmic ray detector. :Author: Curtis McCully Astro-SCRAPPY is designed to detect cosmic rays in images (numpy arrays), based on Pieter van Dokkum's L.A.Cosmic algorithm. Much of this was originally adapted from cosmics.py written by Malte Tewes. I have ported all of the slow functions to Cython/C, and optimized where I can. This is designed to be as fast as possible so some of the readability has been sacrificed, specifically in the C code. If you use this code, please cite the Zendo DOI: https://zenodo.org/record/1482019 Please cite the original paper which can be found at: http://www.astro.yale.edu/dokkum/lacosmic/ van Dokkum 2001, PASP, 113, 789, 1420 (article : http://adsabs.harvard.edu/abs/2001PASP..113.1420V) This code requires Cython, preferably version >= 0.21. Parallelization is achieved using OpenMP. This code should compile (although the Cython files may have issues) using a compiler that does not support OMP, e.g. clang. Notes ----- There are some differences from original LA Cosmic: - Automatic recognition of saturated stars. This avoids treating such stars as large cosmic rays. - I have tried to optimize all of the code as much as possible while maintaining the integrity of the algorithm. One of the key speedups is to use a separable median filter instead of the true median filter. While these are not identical, they produce comparable results and the separable version is much faster. - This implementation is much faster than the Python by as much as a factor of ~17 depending on the given parameters, even without running multiple threads. With multiple threads, this can be increased easily by another factor of 2. This implementation is much faster than the original IRAF version, improvment by a factor of ~90. The arrays always must be C-contiguous, thus all loops are y outer, x inner. This follows the astropy.io.fits (pyfits) convention. scipy is required for certain tests to pass, but the code itself does not depend on scipy. License ------- This project is Copyright (c) Astropy Developers and licensed under the terms of the BSD 3-Clause license. See the licenses folder for more information. ././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1714685833.0 astroscrappy-1.2.0/astroscrappy.egg-info/SOURCES.txt0000644000175100001770000000232414615003611021757 0ustar00runnerdocker.gitignore .readthedocs.yml CHANGES.rst MANIFEST.in README.rst pyproject.toml setup.py tox.ini .github/workflows/python-tests.yml astroscrappy/__init__.py astroscrappy/_compiler.c astroscrappy/astroscrappy.c astroscrappy/astroscrappy.pyx astroscrappy/conftest.py astroscrappy/setup_package.py astroscrappy/version.py astroscrappy.egg-info/PKG-INFO astroscrappy.egg-info/SOURCES.txt astroscrappy.egg-info/dependency_links.txt astroscrappy.egg-info/requires.txt astroscrappy.egg-info/top_level.txt astroscrappy/tests/__init__.py astroscrappy/tests/fake_data.py astroscrappy/tests/test_astroscrappy.py astroscrappy/tests/test_cleaning.py astroscrappy/tests/test_gmos.py astroscrappy/tests/test_utils.py astroscrappy/tests/data/gmos.fits astroscrappy/utils/__init__.py astroscrappy/utils/image_utils.pyx astroscrappy/utils/imutils.c astroscrappy/utils/imutils.h astroscrappy/utils/median_utils.pxd astroscrappy/utils/median_utils.pyx astroscrappy/utils/medutils.c astroscrappy/utils/medutils.h astroscrappy/utils/setup_package.py docs/Makefile docs/conf.py docs/index.rst docs/make.bat docs/_templates/autosummary/base.rst docs/_templates/autosummary/class.rst docs/_templates/autosummary/module.rst licenses/LICENSE.rst licenses/README.rst././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1714685833.0 astroscrappy-1.2.0/astroscrappy.egg-info/dependency_links.txt0000644000175100001770000000000114615003611024140 0ustar00runnerdocker ././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1714685833.0 astroscrappy-1.2.0/astroscrappy.egg-info/requires.txt0000644000175100001770000000011114615003611022463 0ustar00runnerdockerastropy numpy [docs] sphinx-astropy [test] Cython pytest-astropy scipy ././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1714685833.0 astroscrappy-1.2.0/astroscrappy.egg-info/top_level.txt0000644000175100001770000000001514615003611022620 0ustar00runnerdockerastroscrappy ././@PaxHeader0000000000000000000000000000003400000000000010212 xustar0028 mtime=1714685833.3694384 astroscrappy-1.2.0/docs/0000755000175100001770000000000014615003611014576 5ustar00runnerdocker././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1714685814.0 astroscrappy-1.2.0/docs/Makefile0000644000175100001770000001074514615003566016256 0ustar00runnerdocker# Makefile for Sphinx documentation # # You can set these variables from the command line. SPHINXOPTS = SPHINXBUILD = sphinx-build PAPER = BUILDDIR = _build # Internal variables. PAPEROPT_a4 = -D latex_paper_size=a4 PAPEROPT_letter = -D latex_paper_size=letter ALLSPHINXOPTS = -d $(BUILDDIR)/doctrees $(PAPEROPT_$(PAPER)) $(SPHINXOPTS) . .PHONY: help clean html dirhtml singlehtml pickle json htmlhelp qthelp devhelp epub latex latexpdf text man changes linkcheck doctest #This is needed with git because git doesn't create a dir if it's empty $(shell [ -d "_static" ] || mkdir -p _static) 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 " text to make text files" @echo " man to make manual pages" @echo " changes to make an overview of all changed/added/deprecated items" @echo " linkcheck to check all external links for integrity" clean: -rm -rf $(BUILDDIR) -rm -rf api -rm -rf 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/Astropy.qhcp" @echo "To view the help file:" @echo "# assistant -collectionFile $(BUILDDIR)/qthelp/Astropy.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/Astropy" @echo "# ln -s $(BUILDDIR)/devhelp $$HOME/.local/share/devhelp/Astropy" @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." 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." 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: @echo "Run 'python setup.py test' in the root directory to run doctests " \ @echo "in the documentation." ././@PaxHeader0000000000000000000000000000003400000000000010212 xustar0028 mtime=1714685833.3574383 astroscrappy-1.2.0/docs/_templates/0000755000175100001770000000000014615003611016733 5ustar00runnerdocker././@PaxHeader0000000000000000000000000000003400000000000010212 xustar0028 mtime=1714685833.3694384 astroscrappy-1.2.0/docs/_templates/autosummary/0000755000175100001770000000000014615003611021321 5ustar00runnerdocker././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1714685814.0 astroscrappy-1.2.0/docs/_templates/autosummary/base.rst0000644000175100001770000000037214615003566023000 0ustar00runnerdocker{% extends "autosummary_core/base.rst" %} {# The template this is inherited from is in astropy/sphinx/ext/templates/autosummary_core. If you want to modify this template, it is strongly recommended that you still inherit from the astropy template. #}././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1714685814.0 astroscrappy-1.2.0/docs/_templates/autosummary/class.rst0000644000175100001770000000037314615003566023174 0ustar00runnerdocker{% extends "autosummary_core/class.rst" %} {# The template this is inherited from is in astropy/sphinx/ext/templates/autosummary_core. If you want to modify this template, it is strongly recommended that you still inherit from the astropy template. #}././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1714685814.0 astroscrappy-1.2.0/docs/_templates/autosummary/module.rst0000644000175100001770000000037414615003566023355 0ustar00runnerdocker{% extends "autosummary_core/module.rst" %} {# The template this is inherited from is in astropy/sphinx/ext/templates/autosummary_core. If you want to modify this template, it is strongly recommended that you still inherit from the astropy template. #}././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1714685814.0 astroscrappy-1.2.0/docs/conf.py0000644000175100001770000001607514615003566016117 0ustar00runnerdocker# -*- coding: utf-8 -*- # Licensed under a 3-clause BSD style license - see LICENSE.rst # # Astropy documentation build configuration file. # # This file is execfile()d with the current directory set to its containing dir. # # Note that not all possible configuration values are present in this file. # # All configuration values have a default. Some values are defined in # the global Astropy configuration which is loaded here before anything else. # See astropy.sphinx.conf for which values are set there. # 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('..')) # IMPORTANT: the above commented section was generated by sphinx-quickstart, but # is *NOT* appropriate for astropy or Astropy affiliated packages. It is left # commented out with this explanation to make it clear why this should not be # done. If the sys.path entry above is added, when the astropy.sphinx.conf # import occurs, it will import the *source* version of astropy instead of the # version installed (if invoked as "make html" or directly with sphinx), or the # version in the build directory (if "python setup.py build_sphinx" is used). # Thus, any C-extensions that are needed to build the documentation will *not* # be accessible, and the documentation will not build correctly. import os import sys import datetime from importlib import import_module try: from sphinx_astropy.conf.v1 import * # noqa except ImportError: print('ERROR: the documentation requires the sphinx-astropy package to be installed') sys.exit(1) # Get configuration information from setup.cfg from configparser import ConfigParser conf = ConfigParser() conf.read([os.path.join(os.path.dirname(__file__), '..', 'setup.cfg')]) setup_cfg = dict(conf.items('metadata')) # -- General configuration ---------------------------------------------------- # By default, highlight as Python 3. highlight_language = 'python3' # If your documentation needs a minimal Sphinx version, state it here. #needs_sphinx = '1.2' # To perform a Sphinx version check that needs to be more specific than # major.minor, call `check_sphinx_version("x.y.z")` here. # check_sphinx_version("1.2.1") # List of patterns, relative to source directory, that match files and # directories to ignore when looking for source files. exclude_patterns.append('_templates') # This is added to the end of RST files - a good place to put substitutions to # be used globally. rst_epilog += """ """ # -- Project information ------------------------------------------------------ # This does not *have* to match the package name, but typically does project = setup_cfg['name'] author = setup_cfg['author'] copyright = '{0}, {1}'.format( datetime.datetime.now().year, setup_cfg['author']) # 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. import_module(setup_cfg['name']) package = sys.modules[setup_cfg['name']] # The short X.Y version. version = package.__version__.split('-', 1)[0] # The full version, including alpha/beta/rc tags. release = package.__version__ # -- Options for HTML output -------------------------------------------------- # A NOTE ON HTML THEMES # The global astropy configuration uses a custom theme, 'bootstrap-astropy', # which is installed along with astropy. A different theme can be used or # the options for this theme can be modified by overriding some of the # variables set in the global configuration. The variables set in the # global configuration are listed below, commented out. # Add any paths that contain custom themes here, relative to this directory. # To use a different custom theme, add the directory containing the theme. #html_theme_path = [] # The theme to use for HTML and HTML Help pages. See the documentation for # a list of builtin themes. To override the custom theme, set this to the # name of a builtin theme or the name of a custom theme in html_theme_path. #html_theme = None # Please update these texts to match the name of your package. html_theme_options = { 'logotext1': 'astro', # white, semi-bold 'logotext2': 'scrappy', # orange, light 'logotext3': ':docs' # white, light } # Custom sidebar templates, maps document names to template names. #html_sidebars = {} # The name of an image file (relative to this directory) to place at the top # of the sidebar. #html_logo = '' # 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 = '' # If not '', a 'Last updated on:' timestamp is inserted at every page bottom, # using the given strftime format. #html_last_updated_fmt = '' # The name for this set of Sphinx documents. If None, it defaults to # " v documentation". html_title = '{0} v{1}'.format(project, release) # Output file base name for HTML help builder. htmlhelp_basename = project + 'doc' # -- Options for LaTeX output ------------------------------------------------- # Grouping the document tree into LaTeX files. List of tuples # (source start file, target name, title, author, documentclass [howto/manual]). latex_documents = [('index', project + '.tex', project + u' Documentation', author, 'manual')] # -- Options for manual page output ------------------------------------------- # One entry per manual page. List of tuples # (source start file, name, description, authors, manual section). man_pages = [('index', project.lower(), project + u' Documentation', [author], 1)] # -- Options for the edit_on_github extension --------------------------------- if setup_cfg.get('edit_on_github').lower() == 'true': extensions += ['sphinx_astropy.ext.edit_on_github'] edit_on_github_project = setup_cfg['github_project'] edit_on_github_branch = "main" edit_on_github_source_root = "" edit_on_github_doc_root = "docs" # -- Resolving issue number to links in changelog ----------------------------- github_issues_url = 'https://github.com/{0}/issues/'.format(setup_cfg['github_project']) # -- Turn on nitpicky mode for sphinx (to warn about references not found) ---- # # nitpicky = True # nitpick_ignore = [] # # Some warnings are impossible to suppress, and you can list specific references # that should be ignored in a nitpick-exceptions file which should be inside # the docs/ directory. The format of the file should be: # # # # for example: # # py:class astropy.io.votable.tree.Element # py:class astropy.io.votable.tree.SimpleElement # py:class astropy.io.votable.tree.SimpleElementWithContent # # Uncomment the following lines to enable the exceptions: # # for line in open('nitpick-exceptions'): # if line.strip() == "" or line.startswith("#"): # continue # dtype, target = line.split(None, 1) # target = target.strip() # nitpick_ignore.append((dtype, six.u(target))) ././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1714685814.0 astroscrappy-1.2.0/docs/index.rst0000644000175100001770000000011514615003566016445 0ustar00runnerdocker**************** ASTROSCRAPPY **************** .. automodapi:: astroscrappy ././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1714685814.0 astroscrappy-1.2.0/docs/make.bat0000644000175100001770000001064114615003566016216 0ustar00runnerdocker@ECHO OFF REM Command file for Sphinx documentation if "%SPHINXBUILD%" == "" ( set SPHINXBUILD=sphinx-build ) set BUILDDIR=_build set ALLSPHINXOPTS=-d %BUILDDIR%/doctrees %SPHINXOPTS% . if NOT "%PAPER%" == "" ( set ALLSPHINXOPTS=-D latex_paper_size=%PAPER% %ALLSPHINXOPTS% ) if "%1" == "" goto help if "%1" == "help" ( :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. text to make text files echo. man to make manual pages echo. changes to make an overview over all changed/added/deprecated items echo. linkcheck to check all external links for integrity echo. doctest to run all doctests embedded in the documentation if enabled goto end ) if "%1" == "clean" ( for /d %%i in (%BUILDDIR%\*) do rmdir /q /s %%i del /q /s %BUILDDIR%\* goto end ) if "%1" == "html" ( %SPHINXBUILD% -b html %ALLSPHINXOPTS% %BUILDDIR%/html if errorlevel 1 exit /b 1 echo. echo.Build finished. The HTML pages are in %BUILDDIR%/html. goto end ) if "%1" == "dirhtml" ( %SPHINXBUILD% -b dirhtml %ALLSPHINXOPTS% %BUILDDIR%/dirhtml if errorlevel 1 exit /b 1 echo. echo.Build finished. The HTML pages are in %BUILDDIR%/dirhtml. goto end ) if "%1" == "singlehtml" ( %SPHINXBUILD% -b singlehtml %ALLSPHINXOPTS% %BUILDDIR%/singlehtml if errorlevel 1 exit /b 1 echo. echo.Build finished. The HTML pages are in %BUILDDIR%/singlehtml. goto end ) if "%1" == "pickle" ( %SPHINXBUILD% -b pickle %ALLSPHINXOPTS% %BUILDDIR%/pickle if errorlevel 1 exit /b 1 echo. echo.Build finished; now you can process the pickle files. goto end ) if "%1" == "json" ( %SPHINXBUILD% -b json %ALLSPHINXOPTS% %BUILDDIR%/json if errorlevel 1 exit /b 1 echo. echo.Build finished; now you can process the JSON files. goto end ) if "%1" == "htmlhelp" ( %SPHINXBUILD% -b htmlhelp %ALLSPHINXOPTS% %BUILDDIR%/htmlhelp if errorlevel 1 exit /b 1 echo. echo.Build finished; now you can run HTML Help Workshop with the ^ .hhp project file in %BUILDDIR%/htmlhelp. goto end ) if "%1" == "qthelp" ( %SPHINXBUILD% -b qthelp %ALLSPHINXOPTS% %BUILDDIR%/qthelp if errorlevel 1 exit /b 1 echo. echo.Build finished; now you can run "qcollectiongenerator" with the ^ .qhcp project file in %BUILDDIR%/qthelp, like this: echo.^> qcollectiongenerator %BUILDDIR%\qthelp\Astropy.qhcp echo.To view the help file: echo.^> assistant -collectionFile %BUILDDIR%\qthelp\Astropy.ghc goto end ) if "%1" == "devhelp" ( %SPHINXBUILD% -b devhelp %ALLSPHINXOPTS% %BUILDDIR%/devhelp if errorlevel 1 exit /b 1 echo. echo.Build finished. goto end ) if "%1" == "epub" ( %SPHINXBUILD% -b epub %ALLSPHINXOPTS% %BUILDDIR%/epub if errorlevel 1 exit /b 1 echo. echo.Build finished. The epub file is in %BUILDDIR%/epub. goto end ) if "%1" == "latex" ( %SPHINXBUILD% -b latex %ALLSPHINXOPTS% %BUILDDIR%/latex if errorlevel 1 exit /b 1 echo. echo.Build finished; the LaTeX files are in %BUILDDIR%/latex. goto end ) if "%1" == "text" ( %SPHINXBUILD% -b text %ALLSPHINXOPTS% %BUILDDIR%/text if errorlevel 1 exit /b 1 echo. echo.Build finished. The text files are in %BUILDDIR%/text. goto end ) if "%1" == "man" ( %SPHINXBUILD% -b man %ALLSPHINXOPTS% %BUILDDIR%/man if errorlevel 1 exit /b 1 echo. echo.Build finished. The manual pages are in %BUILDDIR%/man. goto end ) if "%1" == "changes" ( %SPHINXBUILD% -b changes %ALLSPHINXOPTS% %BUILDDIR%/changes if errorlevel 1 exit /b 1 echo. echo.The overview file is in %BUILDDIR%/changes. goto end ) if "%1" == "linkcheck" ( %SPHINXBUILD% -b linkcheck %ALLSPHINXOPTS% %BUILDDIR%/linkcheck if errorlevel 1 exit /b 1 echo. echo.Link check complete; look for any errors in the above output ^ or in %BUILDDIR%/linkcheck/output.txt. goto end ) if "%1" == "doctest" ( %SPHINXBUILD% -b doctest %ALLSPHINXOPTS% %BUILDDIR%/doctest if errorlevel 1 exit /b 1 echo. echo.Testing of doctests in the sources finished, look at the ^ results in %BUILDDIR%/doctest/output.txt. goto end ) :end ././@PaxHeader0000000000000000000000000000003400000000000010212 xustar0028 mtime=1714685833.3694384 astroscrappy-1.2.0/licenses/0000755000175100001770000000000014615003611015453 5ustar00runnerdocker././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1714685814.0 astroscrappy-1.2.0/licenses/LICENSE.rst0000644000175100001770000000272314615003566017304 0ustar00runnerdockerCopyright (c) 2015-2018, Curtis McCully 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 Astropy 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 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. ././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1714685814.0 astroscrappy-1.2.0/licenses/README.rst0000644000175100001770000000021414615003566017150 0ustar00runnerdockerLicenses ======== This directory holds license and credit information for the package, works the package is derived from, and/or datasets. ././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1714685814.0 astroscrappy-1.2.0/pyproject.toml0000644000175100001770000000417614615003566016603 0ustar00runnerdocker[build-system] requires = [ "setuptools>=61.2", "setuptools_scm[toml]>=6.2", "extension-helpers==1.*", "numpy>=2.0.0rc1", "Cython>=3.0,<3.1", ] build-backend = 'setuptools.build_meta' [project] name = "astroscrappy" readme = "README.rst" authors = [ { name = "Curtis McCully", email = "cmccully@lco.global" }, ] description = "Speedy Cosmic Ray Annihilation Package in Python" license = { text = "BSD-3-Clause" } # edit-on-github = "False" # github-project = "astropy/astroscrappy" requires-python = ">=3.9" dependencies = [ "astropy", "numpy", ] dynamic = [ "version" ] [project.urls] Homepage = "https://github.com/astropy/astroscrappy" [project.optional-dependencies] docs = ["sphinx-astropy"] test = ["Cython", "pytest-astropy", "scipy"] [tool.setuptools] license-files = ["licenses/LICENSE.rst"] include-package-data = true [tool.setuptools.packages.find] include = ["astroscrappy*"] [tool.setuptools.package-data] "*" = [ "data/*" ] [tool.setuptools_scm] write_to = "astroscrappy/version.py" [tool.pytest.ini_options] testpaths = ["astroscrappy", "docs"] astropy_header = true doctest_plus = "enabled" text_file_format = "rst" addopts = "-p no:warnings --doctest-rst" doctest_norecursedirs = ["*/setup_package.py"] filterwarnings = [ # action:message:category:module:lineno # "error", # "ignore:.*divide by zero encountered in double_scalars.*:RuntimeWarning:arviz", ] [tool.coverage.run] source = ["astroscrappy"] plugins = [ "Cython.Coverage" ] omit = [ "astroscrappy/conftest.py", "astroscrappy/*setup_package*", "astroscrappy/tests/*", "astroscrappy/*/tests/*", "astroscrappy/version*", "*/astroscrappy/conftest.py", "*/astroscrappy/*setup_package*", "*/astroscrappy/tests/*", "*/astroscrappy/*/tests/*", "*/astroscrappy/version*", ] [tool.coverage.report] exclude_lines = [ "pragma: no cover", "except ImportError", "raise AssertionError", "raise NotImplementedError", "def main\\(.*\\):", "pragma: py{ignore_python_version}", "def _ipython_key_completions_", ] [tool.cibuildwheel] build-verbosity = 1 environment = { PIP_PREFER_BINARY=1 } ././@PaxHeader0000000000000000000000000000003400000000000010212 xustar0028 mtime=1714685833.3694384 astroscrappy-1.2.0/setup.cfg0000644000175100001770000000004614615003611015467 0ustar00runnerdocker[egg_info] tag_build = tag_date = 0 ././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1714685814.0 astroscrappy-1.2.0/setup.py0000644000175100001770000000112314615003566015366 0ustar00runnerdocker# Licensed under a 3-clause BSD style license - see LICENSE.rst import os from Cython.Build import cythonize from extension_helpers import get_extensions from setuptools import setup ext_modules = get_extensions() compiler_directives = {} if os.getenv('COVERAGE'): print('Adding linetrace directive') compiler_directives['profile'] = True compiler_directives['linetrace'] = True os.environ['CFLAGS'] = '-DCYTHON_TRACE_NOGIL=1 --coverage -fno-inline-functions -O0' ext_modules = cythonize(ext_modules, compiler_directives=compiler_directives) setup(ext_modules=ext_modules) ././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1714685814.0 astroscrappy-1.2.0/tox.ini0000644000175100001770000000451214615003566015174 0ustar00runnerdocker[tox] envlist = py{39,310,311,312}-test{,-alldeps,-devdeps}{,-cov} py{39,310,311,312}-test-numpy{122,124,126} py{39,310,311,312}-test-astropy{53,60} build_docs linkcheck codestyle [testenv] # Pass through the following environment variables which may be needed for the CI passenv = HOME,WINDIR,LC_ALL,LC_CTYPE,CC,CI,COVERAGE setenv = MPLBACKEND=agg devdeps: PIP_EXTRA_INDEX_URL = https://pypi.anaconda.org/scientific-python-nightly-wheels/simple https://pypi.anaconda.org/astropy/simple # Run the tests in a temporary directory to make sure that we don't import # this package from the source tree changedir = .tmp/{envname} # tox environments are constructed with so-called 'factors' (or terms) # separated by hyphens, e.g. test-devdeps-cov. Lines below starting with factor: # will only take effect if that factor is included in the environment name. To # see a list of example environments that can be run, along with a description, # run: # # tox -l -v # description = run tests alldeps: with all optional dependencies devdeps: with the latest developer version of key dependencies oldestdeps: with the oldest supported version of key dependencies cov: and test coverage # The following provides some specific pinnings for key packages deps = numpy122: numpy==1.22.* numpy124: numpy==1.24.* numpy126: numpy==1.26.* astropy53: astropy==5.3.* astropy60: astropy==6.0.* devdeps: numpy>=0.0.dev0 devdeps: astropy>=0.0.dev0 # The following indicates which extras_require from setup.cfg will be installed extras = test alldeps: all commands = pip freeze !cov: pytest --pyargs astroscrappy '{toxinidir}/docs' {posargs} cov: pytest --pyargs astroscrappy '{toxinidir}/docs' --cov astroscrappy --cov-config='{toxinidir}/setup.cfg' {posargs} [testenv:build_docs] changedir = docs description = invoke sphinx-build to build the HTML docs extras = docs commands = pip freeze sphinx-build -W -b html . _build/html [testenv:linkcheck] changedir = docs description = check the links in the HTML docs extras = docs commands = pip freeze sphinx-build -W -b linkcheck . _build/html [testenv:codestyle] skip_install = true changedir = . description = check code style, e.g. with flake8 deps = flake8 commands = flake8 astroscrappy --count --max-line-length=100