From 15405bf8a35679b5689f14e5c0f2ac0141b249ba Mon Sep 17 00:00:00 2001 From: nat Date: Sat, 7 Jun 2025 23:30:56 -0700 Subject: [PATCH] switch to using shell builtins for thought rendering --- www/build.sh | 1 + www/src/scripts/builtins/bash.h | 62 + www/src/scripts/builtins/build.sh | 39 + www/src/scripts/builtins/execute-bash/builtin | Bin 0 -> 297008 bytes .../scripts/builtins/execute-bash/builtin.c | 4 + .../builtins/execute-bash/execute_bash.c | 9024 +++++++++++++++++ .../builtins/execute-bash/execute_bash.py | 11 + www/src/scripts/execute-bash | 11 - www/src/scripts/include | 6 +- 9 files changed, 9144 insertions(+), 14 deletions(-) create mode 100644 www/src/scripts/builtins/bash.h create mode 100755 www/src/scripts/builtins/build.sh create mode 100755 www/src/scripts/builtins/execute-bash/builtin create mode 100644 www/src/scripts/builtins/execute-bash/builtin.c create mode 100644 www/src/scripts/builtins/execute-bash/execute_bash.c create mode 100644 www/src/scripts/builtins/execute-bash/execute_bash.py delete mode 100755 www/src/scripts/execute-bash diff --git a/www/build.sh b/www/build.sh index 2f221d5..9fd5ab4 100755 --- a/www/build.sh +++ b/www/build.sh @@ -5,6 +5,7 @@ rm -rf site/html mkdir -p site/{html,assets,scripts} cp -r src/output/* site/html echo 'html generated' +(cd ./src/scripts/builtins; ./build.sh) cp -r src/scripts site/ echo 'scripts copied' cp -r src/assets site/ diff --git a/www/src/scripts/builtins/bash.h b/www/src/scripts/builtins/bash.h new file mode 100644 index 0000000..db9a719 --- /dev/null +++ b/www/src/scripts/builtins/bash.h @@ -0,0 +1,62 @@ +#include + +#include +#include +#include +#include + +extern char **make_builtin_argv(WORD_LIST*, int*); + +#define DEFINE_BUILTIN(name) \ + struct builtin name##_struct = { \ + #name, \ + name##_builtin_func, \ + BUILTIN_ENABLED, \ + NULL, \ + NULL, \ + 0 \ + } + +#define WRAP_FUNC_WITH_BUILTIN(name)\ + int name##_builtin_func(WORD_LIST *list) { \ + int argc, ret; \ + char **argv; \ + argv = make_builtin_argv(list, &argc); \ + ret = name(argc, argv); \ + free(argv); \ + return ret;\ + } + +#define PY_FUNC(bash_name, modname, function) \ + int bash_name(int argc, char **argv) { \ + if (!Py_IsInitialized()) { \ + dlopen("libpython3.13.so", RTLD_NOW | RTLD_GLOBAL);\ + PyImport_AppendInittab(#modname, PyInit_##modname); \ + Py_Initialize(); \ + } \ + int ret = 1; \ + PyObject *mod = NULL, *func = NULL, *result; \ + \ + mod = PyImport_ImportModule(#modname); \ + func = PyObject_GetAttrString(mod, #function); \ + \ + PyObject *py_argv = PyTuple_New(argc - 1); \ + \ + for (int i = 1; i < argc; i++) { \ + PyObject *arg_as_str = PyUnicode_FromString(argv[i]); \ + PyTuple_SetItem(py_argv, i-1, arg_as_str); \ + } \ + \ + result = PyObject_CallObject(func, py_argv); \ + if (!result) { PyErr_Print(); goto finally; } \ + ret = (int) PyFloat_AsDouble(result); \ + \ + finally: \ + Py_XDECREF(result); \ + Py_XDECREF(py_argv); \ + Py_XDECREF(func); \ + Py_XDECREF(mod); \ + return ret; \ + } \ + WRAP_FUNC_WITH_BUILTIN(bash_name); \ + DEFINE_BUILTIN(bash_name); diff --git a/www/src/scripts/builtins/build.sh b/www/src/scripts/builtins/build.sh new file mode 100755 index 0000000..e2d9c0f --- /dev/null +++ b/www/src/scripts/builtins/build.sh @@ -0,0 +1,39 @@ +#!/bin/bash +# maybe uses non-posix regex and thus may be non-portable. oops. +# the bash regex implementation is actually platform dependent, lol. + +shopt -s extglob + +PY_VERSION=3.13 +PYFLAGS="$(/usr/bin/python${PY_VERSION}-config --cflags --ldflags)" +BASH_INCLUDE_DIR="/usr/include/bash" + +function translate_function_names() { + # cython generates garbled names like __pyx_pf_7py_test_2foo for a python function named foo + # this function generates a list of #defines that translate these names to what they are in python + + file="${1}" + + grep 'static PyObject \*__pyx_pf_' "${file}" | grep -v 'proto' | while read -r line; do + desired_name=$"${line#*$"${file/.c/}"_}" + desired_name="${desired_name/#+([0-9])/}" + real_name="${line#*\*}" + echo "#define ${desired_name%(*} ${real_name%(*}" +done +} + +py2c() { + rm "${1/.py/.c}" + cython3 -3 "${1}" -o "${1/.py/.c}" + translate_function_names $(basename ${1/.py/.c}) >> "${1/.py/.c}" +} + +compile() { + gcc -I$BASH_INCLUDE_DIR{/include,/builtins,}\ + $PYFLAGS $1 -o ${1/.c/} -Wall\ + -lpython3.13 \ + -fPIC -shared -O3 +} + +py2c execute-bash/execute_bash.py +compile execute-bash/builtin.c diff --git a/www/src/scripts/builtins/execute-bash/builtin b/www/src/scripts/builtins/execute-bash/builtin new file mode 100755 index 0000000000000000000000000000000000000000..0affcb334829c8792d32947f9d184b448fd02f65 GIT binary patch literal 297008 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

(a)q~{x2H5bl#{I1e<8Qr9 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 Um9I&N#{d1TCVxW&Lqw4MAKr=aOaK4? literal 0 HcmV?d00001 diff --git a/www/src/scripts/builtins/execute-bash/builtin.c b/www/src/scripts/builtins/execute-bash/builtin.c new file mode 100644 index 0000000..a84618a --- /dev/null +++ b/www/src/scripts/builtins/execute-bash/builtin.c @@ -0,0 +1,4 @@ +#include "../bash.h" +#include "execute_bash.c" + +PY_FUNC(execute_bash, execute_bash, _execute_bash) diff --git a/www/src/scripts/builtins/execute-bash/execute_bash.c b/www/src/scripts/builtins/execute-bash/execute_bash.c new file mode 100644 index 0000000..3ac5094 --- /dev/null +++ b/www/src/scripts/builtins/execute-bash/execute_bash.c @@ -0,0 +1,9024 @@ +/* Generated by Cython 3.1.1 */ + +#ifndef PY_SSIZE_T_CLEAN +#define PY_SSIZE_T_CLEAN +#endif /* PY_SSIZE_T_CLEAN */ +/* InitLimitedAPI */ +#if defined(Py_LIMITED_API) && !defined(CYTHON_LIMITED_API) + #define CYTHON_LIMITED_API 1 +#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 < 0x03080000 + #error Cython requires Python 3.8+. +#else +#define __PYX_ABI_VERSION "3_1_1" +#define CYTHON_HEX_VERSION 0x030101F0 +#define CYTHON_FUTURE_DIVISION 1 +/* CModulePreamble */ +#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_CPYTHON_FREETHREADING 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 + #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_AVOID_THREAD_UNSAFE_BORROWED_REFS + #define CYTHON_AVOID_THREAD_UNSAFE_BORROWED_REFS 1 + #undef CYTHON_ASSUME_SAFE_MACROS + #define CYTHON_ASSUME_SAFE_MACROS 0 + #undef CYTHON_ASSUME_SAFE_SIZE + #define CYTHON_ASSUME_SAFE_SIZE 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 1 + #undef CYTHON_USE_MODULE_STATE + #define CYTHON_USE_MODULE_STATE 0 + #undef CYTHON_USE_SYS_MONITORING + #define CYTHON_USE_SYS_MONITORING 0 + #undef CYTHON_USE_TP_FINALIZE + #define CYTHON_USE_TP_FINALIZE 0 + #undef CYTHON_USE_AM_SEND + #define CYTHON_USE_AM_SEND 0 + #undef CYTHON_USE_DICT_VERSIONS + #define CYTHON_USE_DICT_VERSIONS 0 + #undef CYTHON_USE_EXC_INFO_STACK + #define CYTHON_USE_EXC_INFO_STACK 1 + #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_CPYTHON_FREETHREADING 0 + #undef CYTHON_USE_TYPE_SLOTS + #define CYTHON_USE_TYPE_SLOTS 1 + #ifndef CYTHON_USE_TYPE_SPECS + #define CYTHON_USE_TYPE_SPECS 0 + #endif + #undef CYTHON_USE_PYTYPE_LOOKUP + #define CYTHON_USE_PYTYPE_LOOKUP 0 + #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_AVOID_THREAD_UNSAFE_BORROWED_REFS + #define CYTHON_AVOID_THREAD_UNSAFE_BORROWED_REFS 1 + #undef CYTHON_ASSUME_SAFE_MACROS + #define CYTHON_ASSUME_SAFE_MACROS 0 + #ifndef CYTHON_ASSUME_SAFE_SIZE + #define CYTHON_ASSUME_SAFE_SIZE 1 + #endif + #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 + #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_SYS_MONITORING + #define CYTHON_USE_SYS_MONITORING 0 + #ifndef CYTHON_USE_TP_FINALIZE + #define CYTHON_USE_TP_FINALIZE (PYPY_VERSION_NUM >= 0x07030C00) + #endif + #undef CYTHON_USE_AM_SEND + #define CYTHON_USE_AM_SEND 0 + #undef CYTHON_USE_DICT_VERSIONS + #define CYTHON_USE_DICT_VERSIONS 0 + #undef CYTHON_USE_EXC_INFO_STACK + #define CYTHON_USE_EXC_INFO_STACK 0 + #ifndef CYTHON_UPDATE_DESCRIPTOR_DOC + #define CYTHON_UPDATE_DESCRIPTOR_DOC (PYPY_VERSION_NUM >= 0x07031100) + #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_CPYTHON_FREETHREADING 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_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 + #ifndef CYTHON_AVOID_THREAD_UNSAFE_BORROWED_REFS + #define CYTHON_AVOID_THREAD_UNSAFE_BORROWED_REFS 0 + #endif + #undef CYTHON_ASSUME_SAFE_MACROS + #define CYTHON_ASSUME_SAFE_MACROS 0 + #undef CYTHON_ASSUME_SAFE_SIZE + #define CYTHON_ASSUME_SAFE_SIZE 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 (__PYX_LIMITED_VERSION_HEX >= 0x030C0000) + #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 + #undef CYTHON_USE_SYS_MONITORING + #define CYTHON_USE_SYS_MONITORING 0 + #ifndef CYTHON_USE_TP_FINALIZE + #define CYTHON_USE_TP_FINALIZE 0 + #endif + #ifndef CYTHON_USE_AM_SEND + #define CYTHON_USE_AM_SEND (__PYX_LIMITED_VERSION_HEX >= 0x030A0000) + #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 +#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 + #ifdef Py_GIL_DISABLED + #define CYTHON_COMPILING_IN_CPYTHON_FREETHREADING 1 + #else + #define CYTHON_COMPILING_IN_CPYTHON_FREETHREADING 0 + #endif + #if PY_VERSION_HEX < 0x030A0000 + #undef CYTHON_USE_TYPE_SLOTS + #define CYTHON_USE_TYPE_SLOTS 1 + #elif !defined(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 + #ifndef CYTHON_USE_PYLONG_INTERNALS + #define CYTHON_USE_PYLONG_INTERNALS 1 + #endif + #if CYTHON_COMPILING_IN_CPYTHON_FREETHREADING + #undef CYTHON_USE_PYLIST_INTERNALS + #define CYTHON_USE_PYLIST_INTERNALS 0 + #elif !defined(CYTHON_USE_PYLIST_INTERNALS) + #define CYTHON_USE_PYLIST_INTERNALS 1 + #endif + #ifndef CYTHON_USE_UNICODE_INTERNALS + #define CYTHON_USE_UNICODE_INTERNALS 1 + #endif + #if CYTHON_COMPILING_IN_CPYTHON_FREETHREADING || 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 + #if CYTHON_COMPILING_IN_CPYTHON_FREETHREADING + #undef CYTHON_AVOID_THREAD_UNSAFE_BORROWED_REFS + #define CYTHON_AVOID_THREAD_UNSAFE_BORROWED_REFS 1 + #elif !defined(CYTHON_AVOID_THREAD_UNSAFE_BORROWED_REFS) + #define CYTHON_AVOID_THREAD_UNSAFE_BORROWED_REFS 0 + #endif + #ifndef CYTHON_ASSUME_SAFE_MACROS + #define CYTHON_ASSUME_SAFE_MACROS 1 + #endif + #ifndef CYTHON_ASSUME_SAFE_SIZE + #define CYTHON_ASSUME_SAFE_SIZE 1 + #endif + #ifndef CYTHON_UNPACK_METHODS + #define CYTHON_UNPACK_METHODS 1 + #endif + #ifndef CYTHON_FAST_THREAD_STATE + #define CYTHON_FAST_THREAD_STATE 1 + #endif + #if CYTHON_COMPILING_IN_CPYTHON_FREETHREADING + #undef CYTHON_FAST_GIL + #define CYTHON_FAST_GIL 0 + #elif !defined(CYTHON_FAST_GIL) + #define CYTHON_FAST_GIL (PY_VERSION_HEX < 0x030C00A6) + #endif + #ifndef CYTHON_METH_FASTCALL + #define CYTHON_METH_FASTCALL 1 + #endif + #ifndef CYTHON_FAST_PYCALL + #define CYTHON_FAST_PYCALL 1 + #endif + #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_SYS_MONITORING + #define CYTHON_USE_SYS_MONITORING (PY_VERSION_HEX >= 0x030d00B1) + #endif + #ifndef CYTHON_USE_TP_FINALIZE + #define CYTHON_USE_TP_FINALIZE 1 + #endif + #ifndef CYTHON_USE_AM_SEND + #define CYTHON_USE_AM_SEND 1 + #endif + #if CYTHON_COMPILING_IN_CPYTHON_FREETHREADING + #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 && !CYTHON_USE_MODULE_STATE) + #endif + #ifndef 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 (!CYTHON_COMPILING_IN_CPYTHON_FREETHREADING) + #endif +#endif +#ifndef CYTHON_FAST_PYCCALL +#define CYTHON_FAST_PYCCALL CYTHON_FAST_PYCALL +#endif +#ifndef CYTHON_VECTORCALL +#if CYTHON_COMPILING_IN_LIMITED_API +#define CYTHON_VECTORCALL (__PYX_LIMITED_VERSION_HEX >= 0x030C0000) +#else +#define CYTHON_VECTORCALL (CYTHON_FAST_PYCCALL && PY_VERSION_HEX >= 0x030800B1) +#endif +#endif +#define CYTHON_BACKPORT_VECTORCALL (CYTHON_METH_FASTCALL && PY_VERSION_HEX < 0x030800B1) +#if CYTHON_USE_PYLONG_INTERNALS + #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 +#ifndef Py_UNREACHABLE + #define Py_UNREACHABLE() assert(0); abort() +#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)) + +/* CInitCode */ +#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 + +/* PythonCompatibility */ +#define __PYX_BUILD_PY_SSIZE_T "n" +#define CYTHON_FORMAT_SSIZE_T "z" +#define __Pyx_BUILTIN_MODULE_NAME "builtins" +#define __Pyx_DefaultClassType PyType_Type +#if CYTHON_COMPILING_IN_LIMITED_API + #ifndef CO_OPTIMIZED + static int CO_OPTIMIZED; + #endif + #ifndef CO_NEWLOCALS + static int CO_NEWLOCALS; + #endif + #ifndef CO_VARARGS + static int CO_VARARGS; + #endif + #ifndef CO_VARKEYWORDS + static int CO_VARKEYWORDS; + #endif + #ifndef CO_ASYNC_GENERATOR + static int CO_ASYNC_GENERATOR; + #endif + #ifndef CO_GENERATOR + static int CO_GENERATOR; + #endif + #ifndef CO_COROUTINE + static int CO_COROUTINE; + #endif +#else + #ifndef CO_COROUTINE + #define CO_COROUTINE 0x80 + #endif + #ifndef CO_ASYNC_GENERATOR + #define CO_ASYNC_GENERATOR 0x200 + #endif +#endif +static int __Pyx_init_co_variables(void); +#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 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 +#ifndef 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_VERSION_HEX >= 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)(void)) { +#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 < 0x03090000 + #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_PyFrame_SetLineNumber(frame, lineno) +#elif CYTHON_COMPILING_IN_GRAAL + #define __Pyx_PyCode_HasFreeVars(co) (PyCode_GetNumFree(co) > 0) + #define __Pyx_PyFrame_SetLineNumber(frame, lineno) _PyFrame_SetLineNumber((frame), (lineno)) +#else + #define __Pyx_PyCode_HasFreeVars(co) (PyCode_GetNumFree(co) > 0) + #define __Pyx_PyFrame_SetLineNumber(frame, lineno) (frame)->f_lineno = (lineno) +#endif +#if CYTHON_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() +#else + #define __Pyx_PyThreadState_Current _PyThreadState_UncheckedGet() +#endif +#if CYTHON_USE_MODULE_STATE +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; +} +#define __Pyx_PyModule_GetState(o) (__pyx_mstatetype *)__Pyx__PyModule_GetState(o) +#else +#define __Pyx_PyModule_GetState(op) ((void)op,__pyx_mstate_global) +#endif +#define __Pyx_PyObject_GetSlot(obj, name, func_ctype) __Pyx_PyType_GetSlot(Py_TYPE((PyObject *) obj), name, func_ctype) +#define __Pyx_PyObject_TryGetSlot(obj, name, func_ctype) __Pyx_PyType_TryGetSlot(Py_TYPE(obj), name, func_ctype) +#define __Pyx_PyObject_GetSubSlot(obj, sub, name, func_ctype) __Pyx_PyType_GetSubSlot(Py_TYPE(obj), sub, name, func_ctype) +#define __Pyx_PyObject_TryGetSubSlot(obj, sub, name, func_ctype) __Pyx_PyType_TryGetSubSlot(Py_TYPE(obj), sub, name, func_ctype) +#if CYTHON_USE_TYPE_SLOTS + #define __Pyx_PyType_GetSlot(type, name, func_ctype) ((type)->name) + #define __Pyx_PyType_TryGetSlot(type, name, func_ctype) __Pyx_PyType_GetSlot(type, name, func_ctype) + #define __Pyx_PyType_GetSubSlot(type, sub, name, func_ctype) (((type)->sub) ? ((type)->sub->name) : NULL) + #define __Pyx_PyType_TryGetSubSlot(type, sub, name, func_ctype) __Pyx_PyType_GetSubSlot(type, sub, name, func_ctype) +#else + #define __Pyx_PyType_GetSlot(type, name, func_ctype) ((func_ctype) PyType_GetSlot((type), Py_##name)) + #define __Pyx_PyType_TryGetSlot(type, name, func_ctype)\ + ((__PYX_LIMITED_VERSION_HEX >= 0x030A0000 ||\ + (PyType_GetFlags(type) & Py_TPFLAGS_HEAPTYPE) || __Pyx_get_runtime_version() >= 0x030A0000) ?\ + __Pyx_PyType_GetSlot(type, name, func_ctype) : NULL) + #define __Pyx_PyType_GetSubSlot(obj, sub, name, func_ctype) __Pyx_PyType_GetSlot(obj, name, func_ctype) + #define __Pyx_PyType_TryGetSubSlot(obj, sub, name, func_ctype) __Pyx_PyType_TryGetSlot(obj, name, func_ctype) +#endif +#if CYTHON_COMPILING_IN_CPYTHON || defined(_PyDict_NewPresized) +#define __Pyx_PyDict_NewPresized(n) ((n <= 8) ? PyDict_New() : _PyDict_NewPresized(n)) +#else +#define __Pyx_PyDict_NewPresized(n) PyDict_New() +#endif +#define __Pyx_PyNumber_Divide(x,y) PyNumber_TrueDivide(x,y) +#define __Pyx_PyNumber_InPlaceDivide(x,y) PyNumber_InPlaceTrueDivide(x,y) +#if CYTHON_COMPILING_IN_CPYTHON && 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 !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) +#else + #define __Pyx_PyType_GetFlags(tp) (PyType_GetFlags((PyTypeObject *)tp)) + #define __Pyx_PyType_HasFeature(type, feature) PyType_HasFeature(type, feature) +#endif +#define __Pyx_PyObject_GetIterNextFunc(iterator) __Pyx_PyObject_GetSlot(iterator, tp_iternext, iternextfunc) +#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 __Pyx_PyUnicode_READY(op) (0) + #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)) +#else + #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_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 +#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) + #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_PyUnicode_FormatSafe(a, b) ((unlikely((a) == Py_None || (PyUnicode_Check(b) && !PyUnicode_CheckExact(b)))) ? PyNumber_Remainder(a, b) : PyUnicode_Format(a, b)) +#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_COMPILING_IN_LIMITED_API || CYTHON_AVOID_BORROWED_REFS || CYTHON_AVOID_THREAD_UNSAFE_BORROWED_REFS || !CYTHON_ASSUME_SAFE_MACROS + #if __PYX_LIMITED_VERSION_HEX >= 0x030d0000 + #define __Pyx_PyList_GetItemRef(o, i) PyList_GetItemRef(o, i) + #else + #define __Pyx_PyList_GetItemRef(o, i) PySequence_GetItem(o, i) + #endif +#else + #define __Pyx_PyList_GetItemRef(o, i) __Pyx_NewRef(PyList_GET_ITEM(o, i)) +#endif +#if __PYX_LIMITED_VERSION_HEX >= 0x030d0000 +#define __Pyx_PyDict_GetItemRef(dict, key, result) PyDict_GetItemRef(dict, key, result) +#elif CYTHON_AVOID_BORROWED_REFS || CYTHON_AVOID_THREAD_UNSAFE_BORROWED_REFS +static CYTHON_INLINE int __Pyx_PyDict_GetItemRef(PyObject *dict, PyObject *key, PyObject **result) { + *result = PyObject_GetItem(dict, key); + if (*result == NULL) { + if (PyErr_ExceptionMatches(PyExc_KeyError)) { + PyErr_Clear(); + return 0; + } + return -1; + } + return 1; +} +#else +static CYTHON_INLINE int __Pyx_PyDict_GetItemRef(PyObject *dict, PyObject *key, PyObject **result) { + *result = PyDict_GetItemWithError(dict, key); + if (*result == NULL) { + return PyErr_Occurred() ? -1 : 0; + } + Py_INCREF(*result); + return 1; +} +#endif +#if defined(CYTHON_DEBUG_VISIT_CONST) && CYTHON_DEBUG_VISIT_CONST + #define __Pyx_VISIT_CONST(obj) Py_VISIT(obj) +#else + #define __Pyx_VISIT_CONST(obj) +#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_PyTuple_GET_ITEM(o, i) PyTuple_GET_ITEM(o, i) + #define __Pyx_PyList_SET_ITEM(o, i, v) (PyList_SET_ITEM(o, i, v), (0)) + #define __Pyx_PyList_GET_ITEM(o, i) PyList_GET_ITEM(o, i) +#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_PyTuple_GET_ITEM(o, i) PyTuple_GetItem(o, i) + #define __Pyx_PyList_SET_ITEM(o, i, v) PyList_SetItem(o, i, v) + #define __Pyx_PyList_GET_ITEM(o, i) PyList_GetItem(o, i) +#endif +#if CYTHON_ASSUME_SAFE_SIZE + #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) + #define __Pyx_PyUnicode_GET_LENGTH(o) PyUnicode_GET_LENGTH(o) +#else + #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) + #define __Pyx_PyUnicode_GET_LENGTH(o) PyUnicode_GetLength(o) +#endif +#if __PYX_LIMITED_VERSION_HEX >= 0x030d0000 + #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 CYTHON_COMPILING_IN_PYPY && !defined(PyUnicode_InternFromString) + #define PyUnicode_InternFromString(s) PyUnicode_FromString(s) +#endif +#define __Pyx_PyLong_FromHash_t PyLong_FromSsize_t +#define __Pyx_PyLong_AsHash_t __Pyx_PyIndex_AsSsize_t +#if __PYX_LIMITED_VERSION_HEX >= 0x030A0000 + #define __Pyx_PySendResult PySendResult +#else + typedef enum { + PYGEN_RETURN = 0, + PYGEN_ERROR = -1, + PYGEN_NEXT = 1, + } __Pyx_PySendResult; +#endif +#if CYTHON_COMPILING_IN_LIMITED_API || PY_VERSION_HEX < 0x030A00A3 + typedef __Pyx_PySendResult (*__Pyx_pyiter_sendfunc)(PyObject *iter, PyObject *value, PyObject **result); +#else + #define __Pyx_pyiter_sendfunc sendfunc +#endif +#if !CYTHON_USE_AM_SEND +#define __PYX_HAS_PY_AM_SEND 0 +#elif __PYX_LIMITED_VERSION_HEX >= 0x030A0000 +#define __PYX_HAS_PY_AM_SEND 1 +#else +#define __PYX_HAS_PY_AM_SEND 2 // our own backported implementation +#endif +#if __PYX_HAS_PY_AM_SEND < 2 + #define __Pyx_PyAsyncMethodsStruct PyAsyncMethods +#else + typedef struct { + unaryfunc am_await; + unaryfunc am_aiter; + unaryfunc am_anext; + __Pyx_pyiter_sendfunc am_send; + } __Pyx_PyAsyncMethodsStruct; + #define __Pyx_SlotTpAsAsync(s) ((PyAsyncMethods*)(s)) +#endif +#if CYTHON_USE_AM_SEND && PY_VERSION_HEX < 0x030A00F0 + #define __Pyx_TPFLAGS_HAVE_AM_SEND (1UL << 21) +#else + #define __Pyx_TPFLAGS_HAVE_AM_SEND (0) +#endif +#if PY_VERSION_HEX >= 0x03090000 +#define __Pyx_PyInterpreterState_Get() PyInterpreterState_Get() +#else +#define __Pyx_PyInterpreterState_Get() PyThreadState_Get()->interp +#endif +#if CYTHON_COMPILING_IN_LIMITED_API && PY_VERSION_HEX < 0x030A0000 +#ifdef __cplusplus +extern "C" +#endif +PyAPI_FUNC(void *) PyMem_Calloc(size_t nelem, size_t elsize); +#endif +#if CYTHON_COMPILING_IN_LIMITED_API +static int __Pyx_init_co_variable(PyObject *inspect, const char* name, int *write_to) { + int value; + PyObject *py_value = PyObject_GetAttrString(inspect, name); + if (!py_value) return 0; + value = (int) PyLong_AsLong(py_value); + Py_DECREF(py_value); + *write_to = value; + return value != -1 || !PyErr_Occurred(); +} +static int __Pyx_init_co_variables(void) { + PyObject *inspect; + int result; + inspect = PyImport_ImportModule("inspect"); + result = +#if !defined(CO_OPTIMIZED) + __Pyx_init_co_variable(inspect, "CO_OPTIMIZED", &CO_OPTIMIZED) && +#endif +#if !defined(CO_NEWLOCALS) + __Pyx_init_co_variable(inspect, "CO_NEWLOCALS", &CO_NEWLOCALS) && +#endif +#if !defined(CO_VARARGS) + __Pyx_init_co_variable(inspect, "CO_VARARGS", &CO_VARARGS) && +#endif +#if !defined(CO_VARKEYWORDS) + __Pyx_init_co_variable(inspect, "CO_VARKEYWORDS", &CO_VARKEYWORDS) && +#endif +#if !defined(CO_ASYNC_GENERATOR) + __Pyx_init_co_variable(inspect, "CO_ASYNC_GENERATOR", &CO_ASYNC_GENERATOR) && +#endif +#if !defined(CO_GENERATOR) + __Pyx_init_co_variable(inspect, "CO_GENERATOR", &CO_GENERATOR) && +#endif +#if !defined(CO_COROUTINE) + __Pyx_init_co_variable(inspect, "CO_COROUTINE", &CO_COROUTINE) && +#endif + 1; + Py_DECREF(inspect); + return result ? 0 : -1; +} +#else +static int __Pyx_init_co_variables(void) { + return 0; // It's a limited API-only feature +} +#endif + +/* MathInitCode */ +#if defined(_WIN32) || defined(WIN32) || defined(MS_WINDOWS) + #ifndef _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 + +#ifndef CYTHON_CLINE_IN_TRACEBACK_RUNTIME +#define CYTHON_CLINE_IN_TRACEBACK_RUNTIME 0 +#endif +#ifndef CYTHON_CLINE_IN_TRACEBACK +#define CYTHON_CLINE_IN_TRACEBACK CYTHON_CLINE_IN_TRACEBACK_RUNTIME +#endif +#if CYTHON_CLINE_IN_TRACEBACK +#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; } +#else +#define __PYX_MARK_ERR_POS(f_index, lineno) { __pyx_filename = __pyx_f[f_index]; (void) __pyx_filename; __pyx_lineno = lineno; (void) __pyx_lineno; (void) __pyx_clineno; } +#endif +#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__execute_bash +#define __PYX_HAVE_API__execute_bash +/* Early includes */ +#ifdef _OPENMP +#include +#endif /* _OPENMP */ + +#if defined(PYREX_WITHOUT_ASSERTIONS) && !defined(CYTHON_WITHOUT_ASSERTIONS) +#define CYTHON_WITHOUT_ASSERTIONS +#endif + +#define __PYX_DEFAULT_STRING_ENCODING_IS_ASCII 0 +#define __PYX_DEFAULT_STRING_ENCODING_IS_UTF8 0 +#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 CYTHON_ASSUME_SAFE_MACROS + #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_PyByteArray_AsString(s) PyByteArray_AS_STRING(s) +#else + #define __Pyx_PyBytes_AsWritableString(s) ((char*) PyBytes_AsString(s)) + #define __Pyx_PyBytes_AsWritableSString(s) ((signed char*) PyBytes_AsString(s)) + #define __Pyx_PyBytes_AsWritableUString(s) ((unsigned char*) PyBytes_AsString(s)) + #define __Pyx_PyBytes_AsString(s) ((const char*) PyBytes_AsString(s)) + #define __Pyx_PyBytes_AsSString(s) ((const signed char*) PyBytes_AsString(s)) + #define __Pyx_PyBytes_AsUString(s) ((const unsigned char*) PyBytes_AsString(s)) + #define __Pyx_PyByteArray_AsString(s) PyByteArray_AsString(s) +#endif +#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_PyUnicode_FromCString(s) __Pyx_PyUnicode_FromString((const char*)s) +#define __Pyx_PyUnicode_FromOrdinal(o) PyUnicode_FromOrdinal((int)o) +#define __Pyx_PyUnicode_AsUnicode PyUnicode_AsUnicode +static CYTHON_INLINE PyObject *__Pyx_NewRef(PyObject *obj) { +#if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030a0000 || defined(Py_NewRef) + return Py_NewRef(obj); +#else + Py_INCREF(obj); + return obj; +#endif +} +static CYTHON_INLINE PyObject *__Pyx_XNewRef(PyObject *obj) { +#if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030a0000 || defined(Py_XNewRef) + return Py_XNewRef(obj); +#else + Py_XINCREF(obj); + return obj; +#endif +} +static CYTHON_INLINE PyObject *__Pyx_Owned_Py_None(int b); +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_Long(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_PyLong_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)) +#define __Pyx_PyFloat_AS_DOUBLE(x) PyFloat_AS_DOUBLE(x) +#else +#define __Pyx_PyFloat_AsDouble(x) PyFloat_AsDouble(x) +#define __Pyx_PyFloat_AS_DOUBLE(x) PyFloat_AsDouble(x) +#endif +#define __Pyx_PyFloat_AsFloat(x) ((float) __Pyx_PyFloat_AsDouble(x)) +#define __Pyx_PyNumber_Int(x) (PyLong_CheckExact(x) ? __Pyx_NewRef(x) : PyNumber_Long(x)) +#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 __PYX_DEFAULT_STRING_ENCODING_IS_UTF8 + #define __Pyx_PyUnicode_FromStringAndSize(c_str, size) PyUnicode_DecodeUTF8(c_str, size, NULL) +#elif __PYX_DEFAULT_STRING_ENCODING_IS_ASCII + #define __Pyx_PyUnicode_FromStringAndSize(c_str, size) PyUnicode_DecodeASCII(c_str, size, NULL) +#else + #define __Pyx_PyUnicode_FromStringAndSize(c_str, size) PyUnicode_Decode(c_str, size, __PYX_DEFAULT_STRING_ENCODING, NULL) +#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__ */ +/* PretendToInitialize */ +#ifdef __cplusplus +#include +template +static void __Pyx_pretend_to_initialize(T* ptr) { +#if __cplusplus > 201103L + if ((std::is_trivially_default_constructible::value)) +#endif + *ptr = T(); + (void)ptr; +} +#else +static CYTHON_INLINE void __Pyx_pretend_to_initialize(void* ptr) { (void)ptr; } +#endif + + +#if !CYTHON_USE_MODULE_STATE +static PyObject *__pyx_m = NULL; +#endif +static int __pyx_lineno; +static int __pyx_clineno = 0; +static const char * const __pyx_cfilenm = __FILE__; +static const char *__pyx_filename; + +/* #### Code section: filename_table ### */ + +static const char* const __pyx_f[] = { + "execute-bash/execute_bash.py", +}; +/* #### Code section: utility_code_proto_before_types ### */ +/* Atomics.proto */ +#include +#ifndef CYTHON_ATOMICS + #define CYTHON_ATOMICS 1 +#endif +#define __PYX_CYTHON_ATOMICS_ENABLED() CYTHON_ATOMICS +#define __PYX_GET_CYTHON_COMPILING_IN_CPYTHON_FREETHREADING() CYTHON_COMPILING_IN_CPYTHON_FREETHREADING +#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_ptr_type atomic_uintptr_t + #define __pyx_nonatomic_ptr_type uintptr_t + #define __pyx_atomic_incr_relaxed(value) atomic_fetch_add_explicit(value, 1, memory_order_relaxed) + #define __pyx_atomic_incr_acq_rel(value) atomic_fetch_add_explicit(value, 1, memory_order_acq_rel) + #define __pyx_atomic_decr_acq_rel(value) atomic_fetch_sub_explicit(value, 1, memory_order_acq_rel) + #define __pyx_atomic_sub(value, arg) atomic_fetch_sub(value, arg) + #define __pyx_atomic_int_cmp_exchange(value, expected, desired) atomic_compare_exchange_strong(value, expected, desired) + #define __pyx_atomic_load(value) atomic_load(value) + #define __pyx_atomic_store(value, new_value) atomic_store(value, new_value) + #define __pyx_atomic_pointer_load_relaxed(value) atomic_load_explicit(value, memory_order_relaxed) + #define __pyx_atomic_pointer_load_acquire(value) atomic_load_explicit(value, memory_order_acquire) + #define __pyx_atomic_pointer_exchange(value, new_value) atomic_exchange(value, (__pyx_nonatomic_ptr_type)new_value) + #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_ptr_type std::atomic_uintptr_t + #define __pyx_nonatomic_ptr_type uintptr_t + #define __pyx_atomic_incr_relaxed(value) std::atomic_fetch_add_explicit(value, 1, std::memory_order_relaxed) + #define __pyx_atomic_incr_acq_rel(value) std::atomic_fetch_add_explicit(value, 1, std::memory_order_acq_rel) + #define __pyx_atomic_decr_acq_rel(value) std::atomic_fetch_sub_explicit(value, 1, std::memory_order_acq_rel) + #define __pyx_atomic_sub(value, arg) std::atomic_fetch_sub(value, arg) + #define __pyx_atomic_int_cmp_exchange(value, expected, desired) std::atomic_compare_exchange_strong(value, expected, desired) + #define __pyx_atomic_load(value) std::atomic_load(value) + #define __pyx_atomic_store(value, new_value) std::atomic_store(value, new_value) + #define __pyx_atomic_pointer_load_relaxed(value) std::atomic_load_explicit(value, std::memory_order_relaxed) + #define __pyx_atomic_pointer_load_acquire(value) std::atomic_load_explicit(value, std::memory_order_acquire) + #define __pyx_atomic_pointer_exchange(value, new_value) std::atomic_exchange(value, (__pyx_nonatomic_ptr_type)new_value) + #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_ptr_type void* + #define __pyx_atomic_incr_relaxed(value) __sync_fetch_and_add(value, 1) + #define __pyx_atomic_incr_acq_rel(value) __sync_fetch_and_add(value, 1) + #define __pyx_atomic_decr_acq_rel(value) __sync_fetch_and_sub(value, 1) + #define __pyx_atomic_sub(value, arg) __sync_fetch_and_sub(value, arg) + static CYTHON_INLINE int __pyx_atomic_int_cmp_exchange(__pyx_atomic_int_type* value, __pyx_nonatomic_int_type* expected, __pyx_nonatomic_int_type desired) { + __pyx_nonatomic_int_type old = __sync_val_compare_and_swap(value, *expected, desired); + int result = old == *expected; + *expected = old; + return result; + } + #define __pyx_atomic_load(value) __sync_fetch_and_add(value, 0) + #define __pyx_atomic_store(value, new_value) __sync_lock_test_and_set(value, new_value) + #define __pyx_atomic_pointer_load_relaxed(value) __sync_fetch_and_add(value, 0) + #define __pyx_atomic_pointer_load_acquire(value) __sync_fetch_and_add(value, 0) + #define __pyx_atomic_pointer_exchange(value, new_value) __sync_lock_test_and_set(value, (__pyx_atomic_ptr_type)new_value) + #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 + #define __pyx_atomic_ptr_type void* + #undef __pyx_nonatomic_int_type + #define __pyx_nonatomic_int_type long + #pragma intrinsic (_InterlockedExchangeAdd, _InterlockedExchange, _InterlockedCompareExchange, _InterlockedCompareExchangePointer, _InterlockedExchangePointer) + #define __pyx_atomic_incr_relaxed(value) _InterlockedExchangeAdd(value, 1) + #define __pyx_atomic_incr_acq_rel(value) _InterlockedExchangeAdd(value, 1) + #define __pyx_atomic_decr_acq_rel(value) _InterlockedExchangeAdd(value, -1) + #define __pyx_atomic_sub(value, arg) _InterlockedExchangeAdd(value, -arg) + static CYTHON_INLINE int __pyx_atomic_int_cmp_exchange(__pyx_atomic_int_type* value, __pyx_nonatomic_int_type* expected, __pyx_nonatomic_int_type desired) { + __pyx_nonatomic_int_type old = _InterlockedCompareExchange(value, desired, *expected); + int result = old == *expected; + *expected = old; + return result; + } + #define __pyx_atomic_load(value) _InterlockedExchangeAdd(value, 0) + #define __pyx_atomic_store(value, new_value) _InterlockedExchange(value, new_value) + #define __pyx_atomic_pointer_load_relaxed(value) *(void * volatile *)value + #define __pyx_atomic_pointer_load_acquire(value) _InterlockedCompareExchangePointer(value, 0, 0) + #define __pyx_atomic_pointer_exchange(value, new_value) _InterlockedExchangePointer(value, (__pyx_atomic_ptr_type)new_value) + #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_relaxed(__pyx_get_slice_count_pointer(memview)) + #define __pyx_sub_acquisition_count(memview)\ + __pyx_atomic_decr_acq_rel(__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 + +/* IncludeStructmemberH.proto */ +#include + +/* CriticalSections.proto */ +#if !CYTHON_COMPILING_IN_CPYTHON_FREETHREADING +#define __Pyx_PyCriticalSection void* +#define __Pyx_PyCriticalSection2 void* +#define __Pyx_PyCriticalSection_Begin1(cs, arg) (void)cs +#define __Pyx_PyCriticalSection_Begin2(cs, arg1, arg2) (void)cs +#define __Pyx_PyCriticalSection_End1(cs) +#define __Pyx_PyCriticalSection_End2(cs) +#else +#define __Pyx_PyCriticalSection PyCriticalSection +#define __Pyx_PyCriticalSection2 PyCriticalSection2 +#define __Pyx_PyCriticalSection_Begin1 PyCriticalSection_Begin +#define __Pyx_PyCriticalSection_Begin2 PyCriticalSection2_Begin +#define __Pyx_PyCriticalSection_End1 PyCriticalSection_End +#define __Pyx_PyCriticalSection_End2 PyCriticalSection2_End +#endif +#if PY_VERSION_HEX < 0x030d0000 || CYTHON_COMPILING_IN_LIMITED_API +#define __Pyx_BEGIN_CRITICAL_SECTION(o) { +#define __Pyx_END_CRITICAL_SECTION() } +#else +#define __Pyx_BEGIN_CRITICAL_SECTION Py_BEGIN_CRITICAL_SECTION +#define __Pyx_END_CRITICAL_SECTION Py_END_CRITICAL_SECTION +#endif + +/* #### Code section: numeric_typedefs ### */ +/* #### Code section: complex_type_declarations ### */ +/* #### Code section: type_declarations ### */ + +/*--- Type declarations ---*/ +struct __pyx_obj_12execute_bash___pyx_scope_struct___execute_bash; + +/* "execute_bash.py":1 + * def _execute_bash(*args): # <<<<<<<<<<<<<< + * from re import sub + * from os import environ as hy_env +*/ +struct __pyx_obj_12execute_bash___pyx_scope_struct___execute_bash { + PyObject_HEAD + PyObject *__pyx_v_check_output; + PyObject *__pyx_v_env; +}; + +/* #### 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; + #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);\ + } + #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); +#endif +#if CYTHON_COMPILING_IN_CPYTHON || CYTHON_METH_FASTCALL +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_ArgRef_VARARGS(args, i) __Pyx_PySequence_ITEM(args, i) +#elif CYTHON_ASSUME_SAFE_MACROS + #define __Pyx_ArgRef_VARARGS(args, i) __Pyx_NewRef(__Pyx_PyTuple_GET_ITEM(args, i)) +#else + #define __Pyx_ArgRef_VARARGS(args, i) __Pyx_XNewRef(PyTuple_GetItem(args, i)) +#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_ArgRef_FASTCALL(args, i) __Pyx_NewRef(args[i]) + #define __Pyx_NumKwargs_FASTCALL(kwds) __Pyx_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_COMPILING_IN_LIMITED_API + CYTHON_UNUSED static PyObject *__Pyx_KwargsAsDict_FASTCALL(PyObject *kwnames, PyObject *const *kwvalues); + #else + #define __Pyx_KwargsAsDict_FASTCALL(kw, kwvalues) _PyStack_AsDict(kwvalues, kw) + #endif +#else + #define __Pyx_ArgRef_FASTCALL __Pyx_ArgRef_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 +#endif +#define __Pyx_ArgsSlice_VARARGS(args, start, stop) PyTuple_GetSlice(args, start, stop) +#if CYTHON_METH_FASTCALL || (CYTHON_COMPILING_IN_CPYTHON && CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS) +#define __Pyx_ArgsSlice_FASTCALL(args, start, stop) __Pyx_PyTuple_FromArray(args + start, stop - start) +#else +#define __Pyx_ArgsSlice_FASTCALL(args, start, stop) PyTuple_GetSlice(args, start, stop) +#endif + +/* RejectKeywords.proto */ +static void __Pyx_RejectKeywords(const char* function_name, PyObject *kwds); + +/* RaiseDoubleKeywords.proto */ +static void __Pyx_RaiseDoubleKeywordsError(const char* func_name, PyObject* kw_name); + +/* ParseKeywords.proto */ +static CYTHON_INLINE int __Pyx_ParseKeywords( + PyObject *kwds, PyObject *const *kwvalues, PyObject ** const argnames[], + PyObject *kwds2, PyObject *values[], + Py_ssize_t num_pos_args, Py_ssize_t num_kwargs, + const char* function_name, + int ignore_unknown_kwargs +); + +/* CallCFunction.proto */ +#define __Pyx_CallCFunction(cfunc, self, args)\ + ((PyCFunction)(void(*)(void))(cfunc)->func)(self, args) +#define __Pyx_CallCFunctionWithKeywords(cfunc, self, args, kwargs)\ + ((PyCFunctionWithKeywords)(void(*)(void))(cfunc)->func)(self, args, kwargs) +#define __Pyx_CallCFunctionFast(cfunc, self, args, nargs)\ + ((__Pyx_PyCFunctionFast)(void(*)(void))(PyCFunction)(cfunc)->func)(self, args, nargs) +#define __Pyx_CallCFunctionFastWithKeywords(cfunc, self, args, nargs, kwnames)\ + ((__Pyx_PyCFunctionFastWithKeywords)(void(*)(void))(PyCFunction)(cfunc)->func)(self, args, nargs, kwnames) + +/* 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 *const *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" + #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 * const*args, size_t nargs, PyObject *kwargs); + +/* UnpackUnboundCMethod.proto */ +typedef struct { + PyObject *type; + PyObject **method_name; +#if CYTHON_COMPILING_IN_CPYTHON_FREETHREADING && CYTHON_ATOMICS + __pyx_atomic_int_type initialized; +#endif + PyCFunction func; + PyObject *method; + int flag; +} __Pyx_CachedCFunction; +#if CYTHON_COMPILING_IN_CPYTHON_FREETHREADING +static CYTHON_INLINE int __Pyx_CachedCFunction_GetAndSetInitializing(__Pyx_CachedCFunction *cfunc) { +#if !CYTHON_ATOMICS + return 1; +#else + __pyx_nonatomic_int_type expected = 0; + if (__pyx_atomic_int_cmp_exchange(&cfunc->initialized, &expected, 1)) { + return 0; + } + return expected; +#endif +} +static CYTHON_INLINE void __Pyx_CachedCFunction_SetFinishedInitializing(__Pyx_CachedCFunction *cfunc) { +#if CYTHON_ATOMICS + __pyx_atomic_store(&cfunc->initialized, 2); +#endif +} +#else +#define __Pyx_CachedCFunction_GetAndSetInitializing(cfunc) 2 +#define __Pyx_CachedCFunction_SetFinishedInitializing(cfunc) +#endif + +/* CallUnboundCMethod2.proto */ +CYTHON_UNUSED +static PyObject* __Pyx__CallUnboundCMethod2(__Pyx_CachedCFunction* cfunc, PyObject* self, PyObject* arg1, PyObject* arg2); +#if CYTHON_COMPILING_IN_CPYTHON +static CYTHON_INLINE PyObject *__Pyx_CallUnboundCMethod2(__Pyx_CachedCFunction *cfunc, PyObject *self, PyObject *arg1, PyObject *arg2); +#else +#define __Pyx_CallUnboundCMethod2(cfunc, self, arg1, arg2) __Pyx__CallUnboundCMethod2(cfunc, self, arg1, arg2) +#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); + +/* RaiseClosureNameError.proto */ +static void __Pyx_RaiseClosureNameError(const char *varname); + +/* PyObjectFastCallMethod.proto */ +#if CYTHON_VECTORCALL && PY_VERSION_HEX >= 0x03090000 +#define __Pyx_PyObject_FastCallMethod(name, args, nargsf) PyObject_VectorcallMethod(name, args, nargsf, NULL) +#else +static PyObject *__Pyx_PyObject_FastCallMethod(PyObject *name, PyObject *const *args, size_t nargsf); +#endif + +/* PyObjectVectorCallKwBuilder.proto */ +CYTHON_UNUSED static int __Pyx_VectorcallBuilder_AddArg_Check(PyObject *key, PyObject *value, PyObject *builder, PyObject **args, int n); +#if CYTHON_VECTORCALL +#if PY_VERSION_HEX >= 0x03090000 +#define __Pyx_Object_Vectorcall_CallFromBuilder PyObject_Vectorcall +#else +#define __Pyx_Object_Vectorcall_CallFromBuilder _PyObject_Vectorcall +#endif +#define __Pyx_MakeVectorcallBuilderKwds(n) PyTuple_New(n) +static int __Pyx_VectorcallBuilder_AddArg(PyObject *key, PyObject *value, PyObject *builder, PyObject **args, int n); +static int __Pyx_VectorcallBuilder_AddArgStr(const char *key, PyObject *value, PyObject *builder, PyObject **args, int n); +#else +#define __Pyx_Object_Vectorcall_CallFromBuilder __Pyx_PyObject_FastCallDict +#define __Pyx_MakeVectorcallBuilderKwds(n) __Pyx_PyDict_NewPresized(n) +#define __Pyx_VectorcallBuilder_AddArg(key, value, builder, args, n) PyDict_SetItem(builder, key, value) +#define __Pyx_VectorcallBuilder_AddArgStr(key, value, builder, args, n) PyDict_SetItemString(builder, key, value) +#endif + +/* Import.proto */ +static PyObject *__Pyx_Import(PyObject *name, PyObject *from_list, int level); + +/* ImportFrom.proto */ +static PyObject* __Pyx_ImportFrom(PyObject* module, PyObject* name); + +/* DictGetItem.proto */ +#if !CYTHON_COMPILING_IN_PYPY +static PyObject *__Pyx_PyDict_GetItem(PyObject *d, PyObject* key); +#define __Pyx_PyObject_Dict_GetItem(obj, name)\ + (likely(PyDict_CheckExact(obj)) ?\ + __Pyx_PyDict_GetItem(obj, name) : PyObject_GetItem(obj, name)) +#else +#define __Pyx_PyDict_GetItem(d, key) PyObject_GetItem(d, key) +#define __Pyx_PyObject_Dict_GetItem(obj, name) PyObject_GetItem(obj, name) +#endif + +/* 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); + +/* PyObjectLookupSpecial.proto */ +#if CYTHON_USE_PYTYPE_LOOKUP && CYTHON_USE_TYPE_SLOTS +#define __Pyx_PyObject_LookupSpecialNoError(obj, attr_name) __Pyx__PyObject_LookupSpecial(obj, attr_name, 0) +#define __Pyx_PyObject_LookupSpecial(obj, attr_name) __Pyx__PyObject_LookupSpecial(obj, attr_name, 1) +static CYTHON_INLINE PyObject* __Pyx__PyObject_LookupSpecial(PyObject* obj, PyObject* attr_name, int with_error); +#else +#define __Pyx_PyObject_LookupSpecialNoError(o,n) __Pyx_PyObject_GetAttrStrNoError(o,n) +#define __Pyx_PyObject_LookupSpecial(o,n) __Pyx_PyObject_GetAttrStr(o,n) +#endif + +/* 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 + +/* FixUpExtensionType.proto */ +static CYTHON_INLINE int __Pyx_fix_up_extension_type_from_spec(PyType_Spec *spec, PyTypeObject *type); + +/* FetchSharedCythonModule.proto */ +static PyObject *__Pyx_FetchSharedCythonABIModule(void); + +/* dict_setdefault.proto */ +static CYTHON_INLINE PyObject *__Pyx_PyDict_SetDefault(PyObject *d, PyObject *key, PyObject *default_value, int is_safe_type); + +/* FetchCommonType.proto */ +static PyTypeObject* __Pyx_FetchCommonTypeFromSpec(PyObject *module, PyType_Spec *spec, PyObject *bases); + +/* CallTypeTraverse.proto */ +#if !CYTHON_USE_TYPE_SPECS || (!CYTHON_COMPILING_IN_LIMITED_API && PY_VERSION_HEX < 0x03090000) +#define __Pyx_call_type_traverse(o, always_call, visit, arg) 0 +#else +static int __Pyx_call_type_traverse(PyObject *o, int always_call, visitproc visit, void *arg); +#endif + +/* PyMethodNew.proto */ +static PyObject *__Pyx_PyMethod_New(PyObject *func, PyObject *self, PyObject *typ); + +/* PyVectorcallFastCallDict.proto */ +#if CYTHON_METH_FASTCALL && (CYTHON_VECTORCALL || CYTHON_BACKPORT_VECTORCALL) +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 ||\ + (CYTHON_COMPILING_IN_LIMITED_API && CYTHON_METH_FASTCALL) + __pyx_vectorcallfunc func_vectorcall; +#endif +#if 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 + PyObject *defaults; + 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_mstate_global->__pyx_CyFunctionType) +#define __Pyx_CyOrPyCFunction_Check(obj) __Pyx_TypeCheck2(obj, __pyx_mstate_global->__pyx_CyFunctionType, &PyCFunction_Type) +#define __Pyx_CyFunction_CheckExact(obj) __Pyx_IS_TYPE(obj, __pyx_mstate_global->__pyx_CyFunctionType) +static CYTHON_INLINE int __Pyx__IsSameCyOrCFunction(PyObject *func, void (*cfunc)(void)); +#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 PyObject *__Pyx_CyFunction_InitDefaults(PyObject *func, + PyTypeObject *defaults_type); +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 || CYTHON_COMPILING_IN_LIMITED_API +#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); + +/* RaiseUnboundLocalError.proto */ +static void __Pyx_RaiseUnboundLocalError(const char *varname); + +/* PyObjectCallNoArg.proto */ +static CYTHON_INLINE PyObject* __Pyx_PyObject_CallNoArg(PyObject *func); + +/* PyObjectCallOneArg.proto */ +static CYTHON_INLINE PyObject* __Pyx_PyObject_CallOneArg(PyObject *func, PyObject *arg); + +/* 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); + +/* 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 + +/* CLineInTraceback.proto */ +#if CYTHON_CLINE_IN_TRACEBACK && CYTHON_CLINE_IN_TRACEBACK_RUNTIME +static int __Pyx_CLineForTraceback(PyThreadState *tstate, int c_line); +#else +#define __Pyx_CLineForTraceback(tstate, c_line) (((CYTHON_CLINE_IN_TRACEBACK)) ? c_line : 0) +#endif + +/* CodeObjectCache.proto */ +#if CYTHON_COMPILING_IN_LIMITED_API +typedef PyObject __Pyx_CachedCodeObjectType; +#else +typedef PyCodeObject __Pyx_CachedCodeObjectType; +#endif +typedef struct { + __Pyx_CachedCodeObjectType* code_object; + int code_line; +} __Pyx_CodeObjectCacheEntry; +struct __Pyx_CodeObjectCache { + int count; + int max_count; + __Pyx_CodeObjectCacheEntry* entries; + #if CYTHON_COMPILING_IN_CPYTHON_FREETHREADING + __pyx_atomic_int_type accessor_count; + #endif +}; +static int __pyx_bisect_code_objects(__Pyx_CodeObjectCacheEntry* entries, int count, int code_line); +static __Pyx_CachedCodeObjectType *__pyx_find_code_object(int code_line); +static void __pyx_insert_code_object(int code_line, __Pyx_CachedCodeObjectType* code_object); + +/* AddTraceback.proto */ +static void __Pyx_AddTraceback(const char *funcname, int c_line, + int py_line, const char *filename); + +/* GCCDiagnostics.proto */ +#if !defined(__INTEL_COMPILER) && defined(__GNUC__) && (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 6)) +#define __Pyx_HAS_GCC_DIAGNOSTIC +#endif + +/* CIntToPy.proto */ +static CYTHON_INLINE PyObject* __Pyx_PyLong_From_long(long value); + +/* FormatTypeName.proto */ +#if CYTHON_COMPILING_IN_LIMITED_API +typedef PyObject *__Pyx_TypeName; +#define __Pyx_FMT_TYPENAME "%U" +#define __Pyx_DECREF_TypeName(obj) Py_XDECREF(obj) +#if __PYX_LIMITED_VERSION_HEX >= 0x030d0000 +#define __Pyx_PyType_GetFullyQualifiedName PyType_GetFullyQualifiedName +#else +static __Pyx_TypeName __Pyx_PyType_GetFullyQualifiedName(PyTypeObject* tp); +#endif +#else // !LIMITED_API +typedef const char *__Pyx_TypeName; +#define __Pyx_FMT_TYPENAME "%.200s" +#define __Pyx_PyType_GetFullyQualifiedName(tp) ((tp)->tp_name) +#define __Pyx_DECREF_TypeName(obj) +#endif + +/* CIntFromPy.proto */ +static CYTHON_INLINE long __Pyx_PyLong_As_long(PyObject *); + +/* CIntFromPy.proto */ +static CYTHON_INLINE int __Pyx_PyLong_As_int(PyObject *); + +/* 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) +static CYTHON_INLINE int __Pyx_PyErr_GivenExceptionMatches2(PyObject *err, PyObject *type1, PyObject *type2) { + return 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) +#ifdef PyExceptionInstance_Check + #define __Pyx_PyBaseException_Check(obj) PyExceptionInstance_Check(obj) +#else + #define __Pyx_PyBaseException_Check(obj) __Pyx_TypeCheck(obj, PyExc_BaseException) +#endif + +/* GetRuntimeVersion.proto */ +static unsigned long __Pyx_get_runtime_version(void); + +/* CheckBinaryVersion.proto */ +static int __Pyx_check_binary_version(unsigned long ct_version, unsigned long rt_version, int allow_newer); + +/* MultiPhaseInitModuleState.proto */ +#if CYTHON_PEP489_MULTI_PHASE_INIT && CYTHON_USE_MODULE_STATE +static PyObject *__Pyx_State_FindModule(void*); +static int __Pyx_State_AddModule(PyObject* module, void*); +static int __Pyx_State_RemoveModule(void*); +#elif CYTHON_USE_MODULE_STATE +#define __Pyx_State_FindModule PyState_FindModule +#define __Pyx_State_AddModule PyState_AddModule +#define __Pyx_State_RemoveModule PyState_RemoveModule +#endif + +/* #### Code section: module_declarations ### */ +/* CythonABIVersion.proto */ +#if CYTHON_COMPILING_IN_LIMITED_API + #if CYTHON_METH_FASTCALL + #define __PYX_FASTCALL_ABI_SUFFIX "_fastcall" + #else + #define __PYX_FASTCALL_ABI_SUFFIX + #endif + #define __PYX_LIMITED_ABI_SUFFIX "limited" __PYX_FASTCALL_ABI_SUFFIX __PYX_AM_SEND_ABI_SUFFIX +#else + #define __PYX_LIMITED_ABI_SUFFIX +#endif +#if __PYX_HAS_PY_AM_SEND == 1 + #define __PYX_AM_SEND_ABI_SUFFIX +#elif __PYX_HAS_PY_AM_SEND == 2 + #define __PYX_AM_SEND_ABI_SUFFIX "amsendbackport" +#else + #define __PYX_AM_SEND_ABI_SUFFIX "noamsend" +#endif +#ifndef __PYX_MONITORING_ABI_SUFFIX + #define __PYX_MONITORING_ABI_SUFFIX +#endif +#if CYTHON_USE_TP_FINALIZE + #define __PYX_TP_FINALIZE_ABI_SUFFIX +#else + #define __PYX_TP_FINALIZE_ABI_SUFFIX "nofinalize" +#endif +#if CYTHON_USE_FREELISTS || !defined(__Pyx_AsyncGen_USED) + #define __PYX_FREELISTS_ABI_SUFFIX +#else + #define __PYX_FREELISTS_ABI_SUFFIX "nofreelists" +#endif +#define CYTHON_ABI __PYX_ABI_VERSION __PYX_LIMITED_ABI_SUFFIX __PYX_MONITORING_ABI_SUFFIX __PYX_TP_FINALIZE_ABI_SUFFIX __PYX_FREELISTS_ABI_SUFFIX __PYX_AM_SEND_ABI_SUFFIX +#define __PYX_ABI_MODULE_NAME "_cython_" CYTHON_ABI +#define __PYX_TYPE_MODULE_PREFIX __PYX_ABI_MODULE_NAME "." + + +/* Module declarations from "execute_bash" */ +/* #### Code section: typeinfo ### */ +/* #### Code section: before_global_var ### */ +#define __Pyx_MODULE_NAME "execute_bash" +extern int __pyx_module_is_main_execute_bash; +int __pyx_module_is_main_execute_bash = 0; + +/* Implementation of "execute_bash" */ +/* #### Code section: global_var ### */ +static PyObject *__pyx_builtin_open; +static PyObject *__pyx_builtin_print; +/* #### Code section: string_decls ### */ +static const char __pyx_k_[] = "."; +static const char __pyx_k_r[] = "r"; +static const char __pyx_k__2[] = "\\$\\[(.*?)\\]"; +static const char __pyx_k__3[] = "?"; +static const char __pyx_k_fp[] = "fp"; +static const char __pyx_k_gc[] = "gc"; +static const char __pyx_k_os[] = "os"; +static const char __pyx_k_re[] = "re"; +static const char __pyx_k_env[] = "env"; +static const char __pyx_k_pop[] = "pop"; +static const char __pyx_k_sub[] = "sub"; +static const char __pyx_k_PATH[] = "PATH"; +static const char __pyx_k_args[] = "args"; +static const char __pyx_k_exit[] = "__exit__"; +static const char __pyx_k_func[] = "__func__"; +static const char __pyx_k_main[] = "__main__"; +static const char __pyx_k_name[] = "__name__"; +static const char __pyx_k_open[] = "open"; +static const char __pyx_k_path[] = "path"; +static const char __pyx_k_read[] = "read"; +static const char __pyx_k_test[] = "__test__"; +static const char __pyx_k_enter[] = "__enter__"; +static const char __pyx_k_group[] = "group"; +static const char __pyx_k_print[] = "print"; +static const char __pyx_k_shell[] = "shell"; +static const char __pyx_k_strip[] = "strip"; +static const char __pyx_k_decode[] = "decode"; +static const char __pyx_k_enable[] = "enable"; +static const char __pyx_k_hy_env[] = "hy_env"; +static const char __pyx_k_lambda[] = ""; +static const char __pyx_k_module[] = "__module__"; +static const char __pyx_k_disable[] = "disable"; +static const char __pyx_k_environ[] = "environ"; +static const char __pyx_k_scripts[] = ":./scripts"; +static const char __pyx_k_bin_bash[] = "/bin/bash"; +static const char __pyx_k_qualname[] = "__qualname__"; +static const char __pyx_k_sequence[] = "sequence"; +static const char __pyx_k_isenabled[] = "isenabled"; +static const char __pyx_k_executable[] = "executable"; +static const char __pyx_k_subprocess[] = "subprocess"; +static const char __pyx_k_check_output[] = "check_output"; +static const char __pyx_k_execute_bash[] = "execute_bash"; +static const char __pyx_k_is_coroutine[] = "_is_coroutine"; +static const char __pyx_k_hy_anon_var_1[] = "_hy_anon_var_1"; +static const char __pyx_k_execute_bash_2[] = "_execute_bash"; +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_execute_bash_locals_lambda[] = "_execute_bash.."; +static const char __pyx_k_execute_bash_execute_bash_py[] = "execute-bash/execute_bash.py"; +static const char __pyx_k_1_1_1_q_1_4q_QfHA_5_Q_Q_Q_R_1[] = "\200\001\330\004\t\210\032\2201\330\004\t\210\032\2201\330\004\t\320\t\033\2301\330\004\n\210!\330\004\007\200q\210\n\220&\230\001\230\030\240\022\2401\330\004\013\2104\210q\220\001\330\t\r\210Q\210f\220H\230A\330\010\031\230\022\2305\240\001\330\004\t\210\021\210#\210Q\320\016 \360\000\000!Q\002\360\000\000Q\002R\002\330\004\013\2101"; +static const char __pyx_k_1_QhfATQWW_hhuuyy_E_E_G_G_M_M_N[] = "\320 1\260\034\270Q\270h\300f\310A\310T\320QW\320W]\320]h\320hu\320uy\320y}\360\000\000~\001E\002\360\000\000E\002G\002\360\000\000G\002M\002\360\000\000M\002N\002"; +/* #### Code section: decls ### */ +static PyObject *__pyx_lambda_funcdef_lambda(PyObject *__pyx_self, PyObject *__pyx_v_sequence); /* proto */ +static PyObject *__pyx_pf_12execute_bash__execute_bash(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_args); /* proto */ +static PyObject *__pyx_tp_new_12execute_bash___pyx_scope_struct___execute_bash(PyTypeObject *t, PyObject *a, PyObject *k); /*proto*/ +/* #### Code section: late_includes ### */ +/* #### Code section: module_state ### */ +/* SmallCodeConfig */ +#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 + +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 + PyObject *__pyx_type_12execute_bash___pyx_scope_struct___execute_bash; + PyTypeObject *__pyx_ptype_12execute_bash___pyx_scope_struct___execute_bash; + __Pyx_CachedCFunction __pyx_umethod_PyDict_Type_pop; + PyObject *__pyx_tuple[1]; + PyObject *__pyx_codeobj_tab[2]; + PyObject *__pyx_string_tab[49]; + PyObject *__pyx_int_0; + PyObject *__pyx_int_1; +/* #### Code section: module_state_contents ### */ +/* CachedMethodType.module_state_decls */ +#if CYTHON_COMPILING_IN_LIMITED_API +PyObject *__Pyx_CachedMethodType; +#endif + + +#if CYTHON_USE_FREELISTS +struct __pyx_obj_12execute_bash___pyx_scope_struct___execute_bash *__pyx_freelist_12execute_bash___pyx_scope_struct___execute_bash[8]; +int __pyx_freecount_12execute_bash___pyx_scope_struct___execute_bash; +#endif +/* CodeObjectCache.module_state_decls */ +struct __Pyx_CodeObjectCache __pyx_code_cache; + +/* #### Code section: module_state_end ### */ +} __pyx_mstatetype; + +#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_global (__Pyx_PyModule_GetState(__Pyx_State_FindModule(&__pyx_moduledef))) + +#define __pyx_m (__Pyx_State_FindModule(&__pyx_moduledef)) +#else +static __pyx_mstatetype __pyx_mstate_global_static = +#ifdef __cplusplus + {}; +#else + {0}; +#endif +static __pyx_mstatetype * const __pyx_mstate_global = &__pyx_mstate_global_static; +#endif +/* #### Code section: constant_name_defines ### */ +#define __pyx_kp_u_ __pyx_string_tab[0] +#define __pyx_n_u_PATH __pyx_string_tab[1] +#define __pyx_kp_u__2 __pyx_string_tab[2] +#define __pyx_kp_u__3 __pyx_string_tab[3] +#define __pyx_n_u_args __pyx_string_tab[4] +#define __pyx_n_u_asyncio_coroutines __pyx_string_tab[5] +#define __pyx_kp_u_bin_bash __pyx_string_tab[6] +#define __pyx_n_u_check_output __pyx_string_tab[7] +#define __pyx_n_u_cline_in_traceback __pyx_string_tab[8] +#define __pyx_n_u_decode __pyx_string_tab[9] +#define __pyx_kp_u_disable __pyx_string_tab[10] +#define __pyx_kp_u_enable __pyx_string_tab[11] +#define __pyx_n_u_enter __pyx_string_tab[12] +#define __pyx_n_u_env __pyx_string_tab[13] +#define __pyx_n_u_environ __pyx_string_tab[14] +#define __pyx_n_u_executable __pyx_string_tab[15] +#define __pyx_n_u_execute_bash __pyx_string_tab[16] +#define __pyx_n_u_execute_bash_2 __pyx_string_tab[17] +#define __pyx_kp_u_execute_bash_execute_bash_py __pyx_string_tab[18] +#define __pyx_n_u_execute_bash_locals_lambda __pyx_string_tab[19] +#define __pyx_n_u_exit __pyx_string_tab[20] +#define __pyx_n_u_fp __pyx_string_tab[21] +#define __pyx_n_u_func __pyx_string_tab[22] +#define __pyx_kp_u_gc __pyx_string_tab[23] +#define __pyx_n_u_group __pyx_string_tab[24] +#define __pyx_n_u_hy_anon_var_1 __pyx_string_tab[25] +#define __pyx_n_u_hy_env __pyx_string_tab[26] +#define __pyx_n_u_is_coroutine __pyx_string_tab[27] +#define __pyx_kp_u_isenabled __pyx_string_tab[28] +#define __pyx_n_u_lambda __pyx_string_tab[29] +#define __pyx_n_u_main __pyx_string_tab[30] +#define __pyx_n_u_module __pyx_string_tab[31] +#define __pyx_n_u_name __pyx_string_tab[32] +#define __pyx_n_u_open __pyx_string_tab[33] +#define __pyx_n_u_os __pyx_string_tab[34] +#define __pyx_n_u_path __pyx_string_tab[35] +#define __pyx_n_u_pop __pyx_string_tab[36] +#define __pyx_n_u_print __pyx_string_tab[37] +#define __pyx_n_u_qualname __pyx_string_tab[38] +#define __pyx_n_u_r __pyx_string_tab[39] +#define __pyx_n_u_re __pyx_string_tab[40] +#define __pyx_n_u_read __pyx_string_tab[41] +#define __pyx_kp_u_scripts __pyx_string_tab[42] +#define __pyx_n_u_sequence __pyx_string_tab[43] +#define __pyx_n_u_shell __pyx_string_tab[44] +#define __pyx_n_u_strip __pyx_string_tab[45] +#define __pyx_n_u_sub __pyx_string_tab[46] +#define __pyx_n_u_subprocess __pyx_string_tab[47] +#define __pyx_n_u_test __pyx_string_tab[48] +/* #### Code section: module_state_clear ### */ +#if CYTHON_USE_MODULE_STATE +static CYTHON_SMALL_CODE int __pyx_m_clear(PyObject *m) { + __pyx_mstatetype *clear_module_state = __Pyx_PyModule_GetState(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 + #if CYTHON_PEP489_MULTI_PHASE_INIT + __Pyx_State_RemoveModule(NULL); + #endif + Py_CLEAR(clear_module_state->__pyx_ptype_12execute_bash___pyx_scope_struct___execute_bash); + Py_CLEAR(clear_module_state->__pyx_type_12execute_bash___pyx_scope_struct___execute_bash); + for (int i=0; i<1; ++i) { Py_CLEAR(clear_module_state->__pyx_tuple[i]); } + for (int i=0; i<2; ++i) { Py_CLEAR(clear_module_state->__pyx_codeobj_tab[i]); } + for (int i=0; i<49; ++i) { Py_CLEAR(clear_module_state->__pyx_string_tab[i]); } + Py_CLEAR(clear_module_state->__pyx_int_0); + Py_CLEAR(clear_module_state->__pyx_int_1); + return 0; +} +#endif +/* #### Code section: module_state_traverse ### */ +#if CYTHON_USE_MODULE_STATE +static CYTHON_SMALL_CODE int __pyx_m_traverse(PyObject *m, visitproc visit, void *arg) { + __pyx_mstatetype *traverse_module_state = __Pyx_PyModule_GetState(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); + __Pyx_VISIT_CONST(traverse_module_state->__pyx_empty_tuple); + __Pyx_VISIT_CONST(traverse_module_state->__pyx_empty_bytes); + __Pyx_VISIT_CONST(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_12execute_bash___pyx_scope_struct___execute_bash); + Py_VISIT(traverse_module_state->__pyx_type_12execute_bash___pyx_scope_struct___execute_bash); + for (int i=0; i<1; ++i) { __Pyx_VISIT_CONST(traverse_module_state->__pyx_tuple[i]); } + for (int i=0; i<2; ++i) { __Pyx_VISIT_CONST(traverse_module_state->__pyx_codeobj_tab[i]); } + for (int i=0; i<49; ++i) { __Pyx_VISIT_CONST(traverse_module_state->__pyx_string_tab[i]); } + __Pyx_VISIT_CONST(traverse_module_state->__pyx_int_0); + __Pyx_VISIT_CONST(traverse_module_state->__pyx_int_1); + return 0; +} +#endif +/* #### Code section: module_code ### */ + +/* "execute_bash.py":1 + * def _execute_bash(*args): # <<<<<<<<<<<<<< + * from re import sub + * from os import environ as hy_env +*/ + +/* Python wrapper */ +static PyObject *__pyx_pw_12execute_bash_1_execute_bash(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/ +static PyMethodDef __pyx_mdef_12execute_bash_1_execute_bash = {"_execute_bash", (PyCFunction)(void(*)(void))(PyCFunctionWithKeywords)__pyx_pw_12execute_bash_1_execute_bash, METH_VARARGS|METH_KEYWORDS, 0}; +static PyObject *__pyx_pw_12execute_bash_1_execute_bash(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds) { + PyObject *__pyx_v_args = 0; + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("_execute_bash (wrapper)", 0); + #if CYTHON_ASSUME_SAFE_SIZE + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs); + const Py_ssize_t __pyx_kwds_len = unlikely(__pyx_kwds) ? __Pyx_NumKwargs_VARARGS(__pyx_kwds) : 0; + if (unlikely(__pyx_kwds_len < 0)) return NULL; + if (unlikely(__pyx_kwds_len > 0)) {__Pyx_RejectKeywords("_execute_bash", __pyx_kwds); return NULL;} + __Pyx_INCREF(__pyx_args); + __pyx_v_args = __pyx_args; + __pyx_r = __pyx_pf_12execute_bash__execute_bash(__pyx_self, __pyx_v_args); + + /* function exit code */ + __Pyx_DECREF(__pyx_v_args); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "execute_bash.py":10 + * with open(path, 'r') as fp: + * _hy_anon_var_1 = fp.read() + * print(sub('\\$\\[(.*?)\\]', lambda sequence: check_output(sequence.group(1), shell=True, executable='/bin/bash', env=env).decode().strip(), _hy_anon_var_1)) # <<<<<<<<<<<<<< + * return 0 +*/ + +/* Python wrapper */ +static PyObject *__pyx_pw_12execute_bash_13_execute_bash_lambda(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_12execute_bash_13_execute_bash_lambda = {"lambda", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_12execute_bash_13_execute_bash_lambda, __Pyx_METH_FASTCALL|METH_KEYWORDS, 0}; +static PyObject *__pyx_pw_12execute_bash_13_execute_bash_lambda(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_sequence = 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("lambda (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_SIZE + __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 ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_sequence,0}; + const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0; + if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(0, 10, __pyx_L3_error) + if (__pyx_kwds_len > 0) { + switch (__pyx_nargs) { + case 1: + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(0, 10, __pyx_L3_error) + CYTHON_FALLTHROUGH; + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + const Py_ssize_t kwd_pos_args = __pyx_nargs; + if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "lambda", 0) < 0) __PYX_ERR(0, 10, __pyx_L3_error) + for (Py_ssize_t i = __pyx_nargs; i < 1; i++) { + if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("lambda", 1, 1, 1, i); __PYX_ERR(0, 10, __pyx_L3_error) } + } + } else if (unlikely(__pyx_nargs != 1)) { + goto __pyx_L5_argtuple_error; + } else { + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(0, 10, __pyx_L3_error) + } + __pyx_v_sequence = values[0]; + } + goto __pyx_L6_skip; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("lambda", 1, 1, 1, __pyx_nargs); __PYX_ERR(0, 10, __pyx_L3_error) + __pyx_L6_skip:; + goto __pyx_L4_argument_unpacking_done; + __pyx_L3_error:; + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); + } + __Pyx_AddTraceback("execute_bash._execute_bash.lambda", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return NULL; + __pyx_L4_argument_unpacking_done:; + __pyx_r = __pyx_lambda_funcdef_lambda(__pyx_self, __pyx_v_sequence); + + /* function exit code */ + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); + } + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_lambda_funcdef_lambda(PyObject *__pyx_self, PyObject *__pyx_v_sequence) { + struct __pyx_obj_12execute_bash___pyx_scope_struct___execute_bash *__pyx_cur_scope; + struct __pyx_obj_12execute_bash___pyx_scope_struct___execute_bash *__pyx_outer_scope; + 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; + PyObject *__pyx_t_8 = NULL; + PyObject *__pyx_t_9 = NULL; + size_t __pyx_t_10; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("lambda", 0); + __pyx_outer_scope = (struct __pyx_obj_12execute_bash___pyx_scope_struct___execute_bash *) __Pyx_CyFunction_GetClosure(__pyx_self); + __pyx_cur_scope = __pyx_outer_scope; + __Pyx_XDECREF(__pyx_r); + __pyx_t_6 = NULL; + if (unlikely(!__pyx_cur_scope->__pyx_v_check_output)) { __Pyx_RaiseClosureNameError("check_output"); __PYX_ERR(0, 10, __pyx_L1_error) } + __Pyx_INCREF(__pyx_cur_scope->__pyx_v_check_output); + __pyx_t_7 = __pyx_cur_scope->__pyx_v_check_output; + __pyx_t_9 = __pyx_v_sequence; + __Pyx_INCREF(__pyx_t_9); + __pyx_t_10 = 0; + { + PyObject *__pyx_callargs[2] = {__pyx_t_9, __pyx_mstate_global->__pyx_int_1}; + __pyx_t_8 = __Pyx_PyObject_FastCallMethod(__pyx_mstate_global->__pyx_n_u_group, __pyx_callargs+__pyx_t_10, (2-__pyx_t_10) | (1*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); + __Pyx_XDECREF(__pyx_t_9); __pyx_t_9 = 0; + if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 10, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_8); + } + if (unlikely(!__pyx_cur_scope->__pyx_v_env)) { __Pyx_RaiseClosureNameError("env"); __PYX_ERR(0, 10, __pyx_L1_error) } + __pyx_t_10 = 1; + #if CYTHON_UNPACK_METHODS + if (unlikely(PyMethod_Check(__pyx_t_7))) { + __pyx_t_6 = PyMethod_GET_SELF(__pyx_t_7); + assert(__pyx_t_6); + PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_7); + __Pyx_INCREF(__pyx_t_6); + __Pyx_INCREF(__pyx__function); + __Pyx_DECREF_SET(__pyx_t_7, __pyx__function); + __pyx_t_10 = 0; + } + #endif + { + PyObject *__pyx_callargs[2 + ((CYTHON_VECTORCALL) ? 3 : 0)] = {__pyx_t_6, __pyx_t_8}; + __pyx_t_9 = __Pyx_MakeVectorcallBuilderKwds(3); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 10, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_9); + if (__Pyx_VectorcallBuilder_AddArg(__pyx_mstate_global->__pyx_n_u_shell, Py_True, __pyx_t_9, __pyx_callargs+2, 0) < 0) __PYX_ERR(0, 10, __pyx_L1_error) + if (__Pyx_VectorcallBuilder_AddArg(__pyx_mstate_global->__pyx_n_u_executable, __pyx_mstate_global->__pyx_kp_u_bin_bash, __pyx_t_9, __pyx_callargs+2, 1) < 0) __PYX_ERR(0, 10, __pyx_L1_error) + if (__Pyx_VectorcallBuilder_AddArg(__pyx_mstate_global->__pyx_n_u_env, __pyx_cur_scope->__pyx_v_env, __pyx_t_9, __pyx_callargs+2, 2) < 0) __PYX_ERR(0, 10, __pyx_L1_error) + __pyx_t_5 = __Pyx_Object_Vectorcall_CallFromBuilder(__pyx_t_7, __pyx_callargs+__pyx_t_10, (2-__pyx_t_10) | (__pyx_t_10*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET), __pyx_t_9); + __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0; + __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; + __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 10, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + } + __pyx_t_4 = __pyx_t_5; + __Pyx_INCREF(__pyx_t_4); + __pyx_t_10 = 0; + { + PyObject *__pyx_callargs[2] = {__pyx_t_4, NULL}; + __pyx_t_3 = __Pyx_PyObject_FastCallMethod(__pyx_mstate_global->__pyx_n_u_decode, __pyx_callargs+__pyx_t_10, (1-__pyx_t_10) | (1*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); + __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 10, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + } + __pyx_t_2 = __pyx_t_3; + __Pyx_INCREF(__pyx_t_2); + __pyx_t_10 = 0; + { + PyObject *__pyx_callargs[2] = {__pyx_t_2, NULL}; + __pyx_t_1 = __Pyx_PyObject_FastCallMethod(__pyx_mstate_global->__pyx_n_u_strip, __pyx_callargs+__pyx_t_10, (1-__pyx_t_10) | (1*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); + __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0; + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 10, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + } + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_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_XDECREF(__pyx_t_8); + __Pyx_XDECREF(__pyx_t_9); + __Pyx_AddTraceback("execute_bash._execute_bash.lambda", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "execute_bash.py":1 + * def _execute_bash(*args): # <<<<<<<<<<<<<< + * from re import sub + * from os import environ as hy_env +*/ + +static PyObject *__pyx_pf_12execute_bash__execute_bash(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_args) { + struct __pyx_obj_12execute_bash___pyx_scope_struct___execute_bash *__pyx_cur_scope; + PyObject *__pyx_v_sub = NULL; + PyObject *__pyx_v_hy_env = NULL; + PyObject *__pyx_v_path = NULL; + PyObject *__pyx_v_fp = NULL; + PyObject *__pyx_v__hy_anon_var_1 = NULL; + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + PyObject *__pyx_t_2 = NULL; + PyObject *__pyx_t_3 = NULL; + size_t __pyx_t_4; + PyObject *__pyx_t_5 = NULL; + PyObject *__pyx_t_6 = NULL; + PyObject *__pyx_t_7 = NULL; + PyObject *__pyx_t_8 = NULL; + PyObject *__pyx_t_9 = NULL; + PyObject *__pyx_t_10 = NULL; + int __pyx_t_11; + int __pyx_t_12; + PyObject *__pyx_t_13 = NULL; + PyObject *__pyx_t_14 = NULL; + PyObject *__pyx_t_15 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("_execute_bash", 0); + __pyx_cur_scope = (struct __pyx_obj_12execute_bash___pyx_scope_struct___execute_bash *)__pyx_tp_new_12execute_bash___pyx_scope_struct___execute_bash(__pyx_mstate_global->__pyx_ptype_12execute_bash___pyx_scope_struct___execute_bash, __pyx_mstate_global->__pyx_empty_tuple, NULL); + if (unlikely(!__pyx_cur_scope)) { + __pyx_cur_scope = ((struct __pyx_obj_12execute_bash___pyx_scope_struct___execute_bash *)Py_None); + __Pyx_INCREF(Py_None); + __PYX_ERR(0, 1, __pyx_L1_error) + } else { + __Pyx_GOTREF((PyObject *)__pyx_cur_scope); + } + + /* "execute_bash.py":2 + * def _execute_bash(*args): + * from re import sub # <<<<<<<<<<<<<< + * from os import environ as hy_env + * from subprocess import check_output +*/ + __pyx_t_1 = PyList_New(1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 2, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_INCREF(__pyx_mstate_global->__pyx_n_u_sub); + __Pyx_GIVEREF(__pyx_mstate_global->__pyx_n_u_sub); + if (__Pyx_PyList_SET_ITEM(__pyx_t_1, 0, __pyx_mstate_global->__pyx_n_u_sub) != (0)) __PYX_ERR(0, 2, __pyx_L1_error); + __pyx_t_2 = __Pyx_Import(__pyx_mstate_global->__pyx_n_u_re, __pyx_t_1, 0); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 2, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_t_1 = __Pyx_ImportFrom(__pyx_t_2, __pyx_mstate_global->__pyx_n_u_sub); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 2, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_INCREF(__pyx_t_1); + __pyx_v_sub = __pyx_t_1; + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + + /* "execute_bash.py":3 + * def _execute_bash(*args): + * from re import sub + * from os import environ as hy_env # <<<<<<<<<<<<<< + * from subprocess import check_output + * env = hy_env +*/ + __pyx_t_2 = PyList_New(1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 3, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_INCREF(__pyx_mstate_global->__pyx_n_u_environ); + __Pyx_GIVEREF(__pyx_mstate_global->__pyx_n_u_environ); + if (__Pyx_PyList_SET_ITEM(__pyx_t_2, 0, __pyx_mstate_global->__pyx_n_u_environ) != (0)) __PYX_ERR(0, 3, __pyx_L1_error); + __pyx_t_1 = __Pyx_Import(__pyx_mstate_global->__pyx_n_u_os, __pyx_t_2, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 3, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __pyx_t_2 = __Pyx_ImportFrom(__pyx_t_1, __pyx_mstate_global->__pyx_n_u_environ); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 3, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_INCREF(__pyx_t_2); + __pyx_v_hy_env = __pyx_t_2; + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "execute_bash.py":4 + * from re import sub + * from os import environ as hy_env + * from subprocess import check_output # <<<<<<<<<<<<<< + * env = hy_env + * env['PATH'] = hy_env['PATH'] + ':./scripts' +*/ + __pyx_t_1 = PyList_New(1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 4, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_INCREF(__pyx_mstate_global->__pyx_n_u_check_output); + __Pyx_GIVEREF(__pyx_mstate_global->__pyx_n_u_check_output); + if (__Pyx_PyList_SET_ITEM(__pyx_t_1, 0, __pyx_mstate_global->__pyx_n_u_check_output) != (0)) __PYX_ERR(0, 4, __pyx_L1_error); + __pyx_t_2 = __Pyx_Import(__pyx_mstate_global->__pyx_n_u_subprocess, __pyx_t_1, 0); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 4, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_t_1 = __Pyx_ImportFrom(__pyx_t_2, __pyx_mstate_global->__pyx_n_u_check_output); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 4, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_INCREF(__pyx_t_1); + __Pyx_GIVEREF(__pyx_t_1); + __pyx_cur_scope->__pyx_v_check_output = __pyx_t_1; + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + + /* "execute_bash.py":5 + * from os import environ as hy_env + * from subprocess import check_output + * env = hy_env # <<<<<<<<<<<<<< + * env['PATH'] = hy_env['PATH'] + ':./scripts' + * path = args[0] +*/ + __Pyx_INCREF(__pyx_v_hy_env); + __Pyx_GIVEREF(__pyx_v_hy_env); + __pyx_cur_scope->__pyx_v_env = __pyx_v_hy_env; + + /* "execute_bash.py":6 + * from subprocess import check_output + * env = hy_env + * env['PATH'] = hy_env['PATH'] + ':./scripts' # <<<<<<<<<<<<<< + * path = args[0] + * with open(path, 'r') as fp: +*/ + __pyx_t_2 = __Pyx_PyObject_Dict_GetItem(__pyx_v_hy_env, __pyx_mstate_global->__pyx_n_u_PATH); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 6, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_1 = PyNumber_Add(__pyx_t_2, __pyx_mstate_global->__pyx_kp_u_scripts); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 6, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + if (unlikely((PyObject_SetItem(__pyx_cur_scope->__pyx_v_env, __pyx_mstate_global->__pyx_n_u_PATH, __pyx_t_1) < 0))) __PYX_ERR(0, 6, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "execute_bash.py":7 + * env = hy_env + * env['PATH'] = hy_env['PATH'] + ':./scripts' + * path = args[0] # <<<<<<<<<<<<<< + * with open(path, 'r') as fp: + * _hy_anon_var_1 = fp.read() +*/ + __pyx_t_1 = __Pyx_GetItemInt_Tuple(__pyx_v_args, 0, long, 1, __Pyx_PyLong_From_long, 0, 0, 1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 7, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_v_path = __pyx_t_1; + __pyx_t_1 = 0; + + /* "execute_bash.py":8 + * env['PATH'] = hy_env['PATH'] + ':./scripts' + * path = args[0] + * with open(path, 'r') as fp: # <<<<<<<<<<<<<< + * _hy_anon_var_1 = fp.read() + * print(sub('\\$\\[(.*?)\\]', lambda sequence: check_output(sequence.group(1), shell=True, executable='/bin/bash', env=env).decode().strip(), _hy_anon_var_1)) +*/ + /*with:*/ { + __pyx_t_2 = NULL; + __Pyx_INCREF(__pyx_builtin_open); + __pyx_t_3 = __pyx_builtin_open; + __pyx_t_4 = 1; + { + PyObject *__pyx_callargs[3] = {__pyx_t_2, __pyx_v_path, __pyx_mstate_global->__pyx_n_u_r}; + __pyx_t_1 = __Pyx_PyObject_FastCall(__pyx_t_3, __pyx_callargs+__pyx_t_4, (3-__pyx_t_4) | (__pyx_t_4*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); + __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0; + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 8, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + } + __pyx_t_5 = __Pyx_PyObject_LookupSpecial(__pyx_t_1, __pyx_mstate_global->__pyx_n_u_exit); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 8, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __pyx_t_2 = NULL; + __pyx_t_6 = __Pyx_PyObject_LookupSpecial(__pyx_t_1, __pyx_mstate_global->__pyx_n_u_enter); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 8, __pyx_L3_error) + __Pyx_GOTREF(__pyx_t_6); + __pyx_t_4 = 1; + #if CYTHON_UNPACK_METHODS + if (likely(PyMethod_Check(__pyx_t_6))) { + __pyx_t_2 = PyMethod_GET_SELF(__pyx_t_6); + assert(__pyx_t_2); + PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_6); + __Pyx_INCREF(__pyx_t_2); + __Pyx_INCREF(__pyx__function); + __Pyx_DECREF_SET(__pyx_t_6, __pyx__function); + __pyx_t_4 = 0; + } + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_2, NULL}; + __pyx_t_3 = __Pyx_PyObject_FastCall(__pyx_t_6, __pyx_callargs+__pyx_t_4, (1-__pyx_t_4) | (__pyx_t_4*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); + __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0; + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 8, __pyx_L3_error) + __Pyx_GOTREF(__pyx_t_3); + } + __pyx_t_6 = __pyx_t_3; + __pyx_t_3 = 0; + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + /*try:*/ { + { + __Pyx_PyThreadState_declare + __Pyx_PyThreadState_assign + __Pyx_ExceptionSave(&__pyx_t_7, &__pyx_t_8, &__pyx_t_9); + __Pyx_XGOTREF(__pyx_t_7); + __Pyx_XGOTREF(__pyx_t_8); + __Pyx_XGOTREF(__pyx_t_9); + /*try:*/ { + __pyx_v_fp = __pyx_t_6; + __pyx_t_6 = 0; + + /* "execute_bash.py":9 + * path = args[0] + * with open(path, 'r') as fp: + * _hy_anon_var_1 = fp.read() # <<<<<<<<<<<<<< + * print(sub('\\$\\[(.*?)\\]', lambda sequence: check_output(sequence.group(1), shell=True, executable='/bin/bash', env=env).decode().strip(), _hy_anon_var_1)) + * return 0 +*/ + __pyx_t_1 = __pyx_v_fp; + __Pyx_INCREF(__pyx_t_1); + __pyx_t_4 = 0; + { + PyObject *__pyx_callargs[2] = {__pyx_t_1, NULL}; + __pyx_t_6 = __Pyx_PyObject_FastCallMethod(__pyx_mstate_global->__pyx_n_u_read, __pyx_callargs+__pyx_t_4, (1-__pyx_t_4) | (1*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); + __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0; + if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 9, __pyx_L7_error) + __Pyx_GOTREF(__pyx_t_6); + } + __pyx_v__hy_anon_var_1 = __pyx_t_6; + __pyx_t_6 = 0; + + /* "execute_bash.py":8 + * env['PATH'] = hy_env['PATH'] + ':./scripts' + * path = args[0] + * with open(path, 'r') as fp: # <<<<<<<<<<<<<< + * _hy_anon_var_1 = fp.read() + * print(sub('\\$\\[(.*?)\\]', lambda sequence: check_output(sequence.group(1), shell=True, executable='/bin/bash', env=env).decode().strip(), _hy_anon_var_1)) +*/ + } + __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; + __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0; + __Pyx_XDECREF(__pyx_t_9); __pyx_t_9 = 0; + goto __pyx_L12_try_end; + __pyx_L7_error:; + __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; + __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0; + /*except:*/ { + __Pyx_AddTraceback("execute_bash._execute_bash", __pyx_clineno, __pyx_lineno, __pyx_filename); + if (__Pyx_GetException(&__pyx_t_6, &__pyx_t_1, &__pyx_t_3) < 0) __PYX_ERR(0, 8, __pyx_L9_except_error) + __Pyx_XGOTREF(__pyx_t_6); + __Pyx_XGOTREF(__pyx_t_1); + __Pyx_XGOTREF(__pyx_t_3); + __pyx_t_2 = PyTuple_Pack(3, __pyx_t_6, __pyx_t_1, __pyx_t_3); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 8, __pyx_L9_except_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_10 = __Pyx_PyObject_Call(__pyx_t_5, __pyx_t_2, NULL); + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 8, __pyx_L9_except_error) + __Pyx_GOTREF(__pyx_t_10); + __pyx_t_11 = __Pyx_PyObject_IsTrue(__pyx_t_10); + __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0; + if (__pyx_t_11 < 0) __PYX_ERR(0, 8, __pyx_L9_except_error) + __pyx_t_12 = (!__pyx_t_11); + if (unlikely(__pyx_t_12)) { + __Pyx_GIVEREF(__pyx_t_6); + __Pyx_GIVEREF(__pyx_t_1); + __Pyx_XGIVEREF(__pyx_t_3); + __Pyx_ErrRestoreWithState(__pyx_t_6, __pyx_t_1, __pyx_t_3); + __pyx_t_6 = 0; __pyx_t_1 = 0; __pyx_t_3 = 0; + __PYX_ERR(0, 8, __pyx_L9_except_error) + } + __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0; + __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0; + __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; + goto __pyx_L8_exception_handled; + } + __pyx_L9_except_error:; + __Pyx_XGIVEREF(__pyx_t_7); + __Pyx_XGIVEREF(__pyx_t_8); + __Pyx_XGIVEREF(__pyx_t_9); + __Pyx_ExceptionReset(__pyx_t_7, __pyx_t_8, __pyx_t_9); + goto __pyx_L1_error; + __pyx_L8_exception_handled:; + __Pyx_XGIVEREF(__pyx_t_7); + __Pyx_XGIVEREF(__pyx_t_8); + __Pyx_XGIVEREF(__pyx_t_9); + __Pyx_ExceptionReset(__pyx_t_7, __pyx_t_8, __pyx_t_9); + __pyx_L12_try_end:; + } + } + /*finally:*/ { + /*normal exit:*/{ + if (__pyx_t_5) { + __pyx_t_9 = __Pyx_PyObject_Call(__pyx_t_5, __pyx_mstate_global->__pyx_tuple[0], NULL); + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 8, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_9); + __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; + } + goto __pyx_L6; + } + __pyx_L6:; + } + goto __pyx_L16; + __pyx_L3_error:; + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + goto __pyx_L1_error; + __pyx_L16:; + } + + /* "execute_bash.py":10 + * with open(path, 'r') as fp: + * _hy_anon_var_1 = fp.read() + * print(sub('\\$\\[(.*?)\\]', lambda sequence: check_output(sequence.group(1), shell=True, executable='/bin/bash', env=env).decode().strip(), _hy_anon_var_1)) # <<<<<<<<<<<<<< + * return 0 +*/ + __pyx_t_1 = NULL; + __Pyx_INCREF(__pyx_builtin_print); + __pyx_t_6 = __pyx_builtin_print; + __pyx_t_13 = NULL; + __Pyx_INCREF(__pyx_v_sub); + __pyx_t_14 = __pyx_v_sub; + __pyx_t_15 = __Pyx_CyFunction_New(&__pyx_mdef_12execute_bash_13_execute_bash_lambda, 0, __pyx_mstate_global->__pyx_n_u_execute_bash_locals_lambda, ((PyObject*)__pyx_cur_scope), __pyx_mstate_global->__pyx_n_u_execute_bash, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[0])); if (unlikely(!__pyx_t_15)) __PYX_ERR(0, 10, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_15); + if (unlikely(!__pyx_v__hy_anon_var_1)) { __Pyx_RaiseUnboundLocalError("_hy_anon_var_1"); __PYX_ERR(0, 10, __pyx_L1_error) } + __pyx_t_4 = 1; + #if CYTHON_UNPACK_METHODS + if (unlikely(PyMethod_Check(__pyx_t_14))) { + __pyx_t_13 = PyMethod_GET_SELF(__pyx_t_14); + assert(__pyx_t_13); + PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_14); + __Pyx_INCREF(__pyx_t_13); + __Pyx_INCREF(__pyx__function); + __Pyx_DECREF_SET(__pyx_t_14, __pyx__function); + __pyx_t_4 = 0; + } + #endif + { + PyObject *__pyx_callargs[4] = {__pyx_t_13, __pyx_mstate_global->__pyx_kp_u__2, __pyx_t_15, __pyx_v__hy_anon_var_1}; + __pyx_t_2 = __Pyx_PyObject_FastCall(__pyx_t_14, __pyx_callargs+__pyx_t_4, (4-__pyx_t_4) | (__pyx_t_4*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); + __Pyx_XDECREF(__pyx_t_13); __pyx_t_13 = 0; + __Pyx_DECREF(__pyx_t_15); __pyx_t_15 = 0; + __Pyx_DECREF(__pyx_t_14); __pyx_t_14 = 0; + if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 10, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + } + __pyx_t_4 = 1; + { + PyObject *__pyx_callargs[2] = {__pyx_t_1, __pyx_t_2}; + __pyx_t_3 = __Pyx_PyObject_FastCall(__pyx_t_6, __pyx_callargs+__pyx_t_4, (2-__pyx_t_4) | (__pyx_t_4*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); + __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0; + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 10, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + } + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + + /* "execute_bash.py":11 + * _hy_anon_var_1 = fp.read() + * print(sub('\\$\\[(.*?)\\]', lambda sequence: check_output(sequence.group(1), shell=True, executable='/bin/bash', env=env).decode().strip(), _hy_anon_var_1)) + * return 0 # <<<<<<<<<<<<<< +*/ + __Pyx_XDECREF(__pyx_r); + __Pyx_INCREF(__pyx_mstate_global->__pyx_int_0); + __pyx_r = __pyx_mstate_global->__pyx_int_0; + goto __pyx_L0; + + /* "execute_bash.py":1 + * def _execute_bash(*args): # <<<<<<<<<<<<<< + * from re import sub + * from os import environ as hy_env +*/ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_XDECREF(__pyx_t_6); + __Pyx_XDECREF(__pyx_t_13); + __Pyx_XDECREF(__pyx_t_14); + __Pyx_XDECREF(__pyx_t_15); + __Pyx_AddTraceback("execute_bash._execute_bash", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XDECREF(__pyx_v_sub); + __Pyx_XDECREF(__pyx_v_hy_env); + __Pyx_XDECREF(__pyx_v_path); + __Pyx_XDECREF(__pyx_v_fp); + __Pyx_XDECREF(__pyx_v__hy_anon_var_1); + __Pyx_DECREF((PyObject *)__pyx_cur_scope); + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} +/* #### Code section: module_exttypes ### */ + +static PyObject *__pyx_tp_new_12execute_bash___pyx_scope_struct___execute_bash(PyTypeObject *t, CYTHON_UNUSED PyObject *a, CYTHON_UNUSED PyObject *k) { + 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 CYTHON_USE_FREELISTS + if (likely((int)(__pyx_mstate_global->__pyx_freecount_12execute_bash___pyx_scope_struct___execute_bash > 0) & (int)(t->tp_basicsize == sizeof(struct __pyx_obj_12execute_bash___pyx_scope_struct___execute_bash)))) { + o = (PyObject*)__pyx_mstate_global->__pyx_freelist_12execute_bash___pyx_scope_struct___execute_bash[--__pyx_mstate_global->__pyx_freecount_12execute_bash___pyx_scope_struct___execute_bash]; + memset(o, 0, sizeof(struct __pyx_obj_12execute_bash___pyx_scope_struct___execute_bash)); + (void) PyObject_INIT(o, t); + PyObject_GC_Track(o); + } else + #endif + { + o = (*t->tp_alloc)(t, 0); + if (unlikely(!o)) return 0; + } + #endif + return o; +} + +static void __pyx_tp_dealloc_12execute_bash___pyx_scope_struct___execute_bash(PyObject *o) { + struct __pyx_obj_12execute_bash___pyx_scope_struct___execute_bash *p = (struct __pyx_obj_12execute_bash___pyx_scope_struct___execute_bash *)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_12execute_bash___pyx_scope_struct___execute_bash) { + if (PyObject_CallFinalizerFromDealloc(o)) return; + } + } + #endif + PyObject_GC_UnTrack(o); + Py_CLEAR(p->__pyx_v_check_output); + Py_CLEAR(p->__pyx_v_env); + #if CYTHON_USE_FREELISTS + if (((int)(__pyx_mstate_global->__pyx_freecount_12execute_bash___pyx_scope_struct___execute_bash < 8) & (int)(Py_TYPE(o)->tp_basicsize == sizeof(struct __pyx_obj_12execute_bash___pyx_scope_struct___execute_bash)))) { + __pyx_mstate_global->__pyx_freelist_12execute_bash___pyx_scope_struct___execute_bash[__pyx_mstate_global->__pyx_freecount_12execute_bash___pyx_scope_struct___execute_bash++] = ((struct __pyx_obj_12execute_bash___pyx_scope_struct___execute_bash *)o); + } else + #endif + { + #if CYTHON_USE_TYPE_SLOTS + (*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_12execute_bash___pyx_scope_struct___execute_bash(PyObject *o, visitproc v, void *a) { + int e; + struct __pyx_obj_12execute_bash___pyx_scope_struct___execute_bash *p = (struct __pyx_obj_12execute_bash___pyx_scope_struct___execute_bash *)o; + { + e = __Pyx_call_type_traverse(o, 1, v, a); + if (e) return e; + } + if (p->__pyx_v_check_output) { + e = (*v)(p->__pyx_v_check_output, a); if (e) return e; + } + if (p->__pyx_v_env) { + e = (*v)(p->__pyx_v_env, a); if (e) return e; + } + return 0; +} + +static int __pyx_tp_clear_12execute_bash___pyx_scope_struct___execute_bash(PyObject *o) { + PyObject* tmp; + struct __pyx_obj_12execute_bash___pyx_scope_struct___execute_bash *p = (struct __pyx_obj_12execute_bash___pyx_scope_struct___execute_bash *)o; + tmp = ((PyObject*)p->__pyx_v_check_output); + p->__pyx_v_check_output = Py_None; Py_INCREF(Py_None); + Py_XDECREF(tmp); + tmp = ((PyObject*)p->__pyx_v_env); + p->__pyx_v_env = Py_None; Py_INCREF(Py_None); + Py_XDECREF(tmp); + return 0; +} +#if CYTHON_USE_TYPE_SPECS +static PyType_Slot __pyx_type_12execute_bash___pyx_scope_struct___execute_bash_slots[] = { + {Py_tp_dealloc, (void *)__pyx_tp_dealloc_12execute_bash___pyx_scope_struct___execute_bash}, + {Py_tp_traverse, (void *)__pyx_tp_traverse_12execute_bash___pyx_scope_struct___execute_bash}, + {Py_tp_clear, (void *)__pyx_tp_clear_12execute_bash___pyx_scope_struct___execute_bash}, + {Py_tp_new, (void *)__pyx_tp_new_12execute_bash___pyx_scope_struct___execute_bash}, + {0, 0}, +}; +static PyType_Spec __pyx_type_12execute_bash___pyx_scope_struct___execute_bash_spec = { + "execute_bash.__pyx_scope_struct___execute_bash", + sizeof(struct __pyx_obj_12execute_bash___pyx_scope_struct___execute_bash), + 0, + Py_TPFLAGS_DEFAULT|Py_TPFLAGS_HAVE_VERSION_TAG|Py_TPFLAGS_CHECKTYPES|Py_TPFLAGS_HAVE_NEWBUFFER|Py_TPFLAGS_HAVE_GC|Py_TPFLAGS_HAVE_FINALIZE, + __pyx_type_12execute_bash___pyx_scope_struct___execute_bash_slots, +}; +#else + +static PyTypeObject __pyx_type_12execute_bash___pyx_scope_struct___execute_bash = { + PyVarObject_HEAD_INIT(0, 0) + "execute_bash.""__pyx_scope_struct___execute_bash", /*tp_name*/ + sizeof(struct __pyx_obj_12execute_bash___pyx_scope_struct___execute_bash), /*tp_basicsize*/ + 0, /*tp_itemsize*/ + __pyx_tp_dealloc_12execute_bash___pyx_scope_struct___execute_bash, /*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*/ + 0, /*tp_as_async*/ + 0, /*tp_repr*/ + 0, /*tp_as_number*/ + 0, /*tp_as_sequence*/ + 0, /*tp_as_mapping*/ + 0, /*tp_hash*/ + 0, /*tp_call*/ + 0, /*tp_str*/ + 0, /*tp_getattro*/ + 0, /*tp_setattro*/ + 0, /*tp_as_buffer*/ + Py_TPFLAGS_DEFAULT|Py_TPFLAGS_HAVE_VERSION_TAG|Py_TPFLAGS_CHECKTYPES|Py_TPFLAGS_HAVE_NEWBUFFER|Py_TPFLAGS_HAVE_GC|Py_TPFLAGS_HAVE_FINALIZE, /*tp_flags*/ + 0, /*tp_doc*/ + __pyx_tp_traverse_12execute_bash___pyx_scope_struct___execute_bash, /*tp_traverse*/ + __pyx_tp_clear_12execute_bash___pyx_scope_struct___execute_bash, /*tp_clear*/ + 0, /*tp_richcompare*/ + 0, /*tp_weaklistoffset*/ + 0, /*tp_iter*/ + 0, /*tp_iternext*/ + 0, /*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_12execute_bash___pyx_scope_struct___execute_bash, /*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 CYTHON_USE_TP_FINALIZE + 0, /*tp_finalize*/ + #else + NULL, /*tp_finalize*/ + #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 PY_VERSION_HEX >= 0x030d00A4 + 0, /*tp_versions_used*/ + #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} +}; +/* #### Code section: initfunc_declarations ### */ +static CYTHON_SMALL_CODE int __Pyx_InitCachedBuiltins(__pyx_mstatetype *__pyx_mstate); /*proto*/ +static CYTHON_SMALL_CODE int __Pyx_InitCachedConstants(__pyx_mstatetype *__pyx_mstate); /*proto*/ +static CYTHON_SMALL_CODE int __Pyx_InitGlobals(void); /*proto*/ +static CYTHON_SMALL_CODE int __Pyx_InitConstants(__pyx_mstatetype *__pyx_mstate); /*proto*/ +static CYTHON_SMALL_CODE int __Pyx_modinit_global_init_code(__pyx_mstatetype *__pyx_mstate); /*proto*/ +static CYTHON_SMALL_CODE int __Pyx_modinit_variable_export_code(__pyx_mstatetype *__pyx_mstate); /*proto*/ +static CYTHON_SMALL_CODE int __Pyx_modinit_function_export_code(__pyx_mstatetype *__pyx_mstate); /*proto*/ +static CYTHON_SMALL_CODE int __Pyx_modinit_type_init_code(__pyx_mstatetype *__pyx_mstate); /*proto*/ +static CYTHON_SMALL_CODE int __Pyx_modinit_type_import_code(__pyx_mstatetype *__pyx_mstate); /*proto*/ +static CYTHON_SMALL_CODE int __Pyx_modinit_variable_import_code(__pyx_mstatetype *__pyx_mstate); /*proto*/ +static CYTHON_SMALL_CODE int __Pyx_modinit_function_import_code(__pyx_mstatetype *__pyx_mstate); /*proto*/ +static CYTHON_SMALL_CODE int __Pyx_CreateCodeObjects(__pyx_mstatetype *__pyx_mstate); /*proto*/ +/* #### Code section: init_module ### */ + +static int __Pyx_modinit_global_init_code(__pyx_mstatetype *__pyx_mstate) { + __Pyx_RefNannyDeclarations + CYTHON_UNUSED_VAR(__pyx_mstate); + __Pyx_RefNannySetupContext("__Pyx_modinit_global_init_code", 0); + /*--- Global init code ---*/ + __Pyx_RefNannyFinishContext(); + return 0; +} + +static int __Pyx_modinit_variable_export_code(__pyx_mstatetype *__pyx_mstate) { + __Pyx_RefNannyDeclarations + CYTHON_UNUSED_VAR(__pyx_mstate); + __Pyx_RefNannySetupContext("__Pyx_modinit_variable_export_code", 0); + /*--- Variable export code ---*/ + __Pyx_RefNannyFinishContext(); + return 0; +} + +static int __Pyx_modinit_function_export_code(__pyx_mstatetype *__pyx_mstate) { + __Pyx_RefNannyDeclarations + CYTHON_UNUSED_VAR(__pyx_mstate); + __Pyx_RefNannySetupContext("__Pyx_modinit_function_export_code", 0); + /*--- Function export code ---*/ + __Pyx_RefNannyFinishContext(); + return 0; +} + +static int __Pyx_modinit_type_init_code(__pyx_mstatetype *__pyx_mstate) { + __Pyx_RefNannyDeclarations + CYTHON_UNUSED_VAR(__pyx_mstate); + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__Pyx_modinit_type_init_code", 0); + /*--- Type init code ---*/ + #if CYTHON_USE_TYPE_SPECS + __pyx_mstate->__pyx_ptype_12execute_bash___pyx_scope_struct___execute_bash = (PyTypeObject *) __Pyx_PyType_FromModuleAndSpec(__pyx_m, &__pyx_type_12execute_bash___pyx_scope_struct___execute_bash_spec, NULL); if (unlikely(!__pyx_mstate->__pyx_ptype_12execute_bash___pyx_scope_struct___execute_bash)) __PYX_ERR(0, 1, __pyx_L1_error) + if (__Pyx_fix_up_extension_type_from_spec(&__pyx_type_12execute_bash___pyx_scope_struct___execute_bash_spec, __pyx_mstate->__pyx_ptype_12execute_bash___pyx_scope_struct___execute_bash) < 0) __PYX_ERR(0, 1, __pyx_L1_error) + #else + __pyx_mstate->__pyx_ptype_12execute_bash___pyx_scope_struct___execute_bash = &__pyx_type_12execute_bash___pyx_scope_struct___execute_bash; + #endif + #if !CYTHON_COMPILING_IN_LIMITED_API + #endif + #if !CYTHON_USE_TYPE_SPECS + if (__Pyx_PyType_Ready(__pyx_mstate->__pyx_ptype_12execute_bash___pyx_scope_struct___execute_bash) < 0) __PYX_ERR(0, 1, __pyx_L1_error) + #endif + #if !CYTHON_COMPILING_IN_LIMITED_API + if ((CYTHON_USE_TYPE_SLOTS && CYTHON_USE_PYTYPE_LOOKUP) && likely(!__pyx_mstate->__pyx_ptype_12execute_bash___pyx_scope_struct___execute_bash->tp_dictoffset && __pyx_mstate->__pyx_ptype_12execute_bash___pyx_scope_struct___execute_bash->tp_getattro == PyObject_GenericGetAttr)) { + __pyx_mstate->__pyx_ptype_12execute_bash___pyx_scope_struct___execute_bash->tp_getattro = PyObject_GenericGetAttr; + } + #endif + __Pyx_RefNannyFinishContext(); + return 0; + __pyx_L1_error:; + __Pyx_RefNannyFinishContext(); + return -1; +} + +static int __Pyx_modinit_type_import_code(__pyx_mstatetype *__pyx_mstate) { + __Pyx_RefNannyDeclarations + CYTHON_UNUSED_VAR(__pyx_mstate); + __Pyx_RefNannySetupContext("__Pyx_modinit_type_import_code", 0); + /*--- Type import code ---*/ + __Pyx_RefNannyFinishContext(); + return 0; +} + +static int __Pyx_modinit_variable_import_code(__pyx_mstatetype *__pyx_mstate) { + __Pyx_RefNannyDeclarations + CYTHON_UNUSED_VAR(__pyx_mstate); + __Pyx_RefNannySetupContext("__Pyx_modinit_variable_import_code", 0); + /*--- Variable import code ---*/ + __Pyx_RefNannyFinishContext(); + return 0; +} + +static int __Pyx_modinit_function_import_code(__pyx_mstatetype *__pyx_mstate) { + __Pyx_RefNannyDeclarations + CYTHON_UNUSED_VAR(__pyx_mstate); + __Pyx_RefNannySetupContext("__Pyx_modinit_function_import_code", 0); + /*--- Function import code ---*/ + __Pyx_RefNannyFinishContext(); + return 0; +} + +#if CYTHON_PEP489_MULTI_PHASE_INIT +static PyObject* __pyx_pymod_create(PyObject *spec, PyModuleDef *def); /*proto*/ +static int __pyx_pymod_exec_execute_bash(PyObject* module); /*proto*/ +static PyModuleDef_Slot __pyx_moduledef_slots[] = { + {Py_mod_create, (void*)__pyx_pymod_create}, + {Py_mod_exec, (void*)__pyx_pymod_exec_execute_bash}, + #if CYTHON_COMPILING_IN_CPYTHON_FREETHREADING + {Py_mod_gil, Py_MOD_GIL_USED}, + #endif + #if PY_VERSION_HEX >= 0x030C0000 && CYTHON_USE_MODULE_STATE + {Py_mod_multiple_interpreters, Py_MOD_MULTIPLE_INTERPRETERS_NOT_SUPPORTED}, + #endif + {0, NULL} +}; +#endif + +#ifdef __cplusplus +namespace { + struct PyModuleDef __pyx_moduledef = + #else + static struct PyModuleDef __pyx_moduledef = + #endif + { + PyModuleDef_HEAD_INIT, + "execute_bash", + 0, /* m_doc */ + #if CYTHON_USE_MODULE_STATE + sizeof(__pyx_mstatetype), /* m_size */ + #else + (CYTHON_PEP489_MULTI_PHASE_INIT) ? 0 : -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 + +/* PyModInitFuncType */ +#ifndef CYTHON_NO_PYINIT_EXPORT + #define __Pyx_PyMODINIT_FUNC PyMODINIT_FUNC +#else + #ifdef __cplusplus + #define __Pyx_PyMODINIT_FUNC extern "C" PyObject * + #else + #define __Pyx_PyMODINIT_FUNC PyObject * + #endif +#endif + +__Pyx_PyMODINIT_FUNC PyInit_execute_bash(void) CYTHON_SMALL_CODE; /*proto*/ +__Pyx_PyMODINIT_FUNC PyInit_execute_bash(void) +#if CYTHON_PEP489_MULTI_PHASE_INIT +{ + return PyModuleDef_Init(&__pyx_moduledef); +} +/* ModuleCreationPEP489 */ +#if CYTHON_COMPILING_IN_LIMITED_API && __PYX_LIMITED_VERSION_HEX < 0x03090000 +static PY_INT64_T __Pyx_GetCurrentInterpreterId(void) { + { + PyObject *module = PyImport_ImportModule("_interpreters"); // 3.13+ I think + if (!module) { + PyErr_Clear(); // just try the 3.8-3.12 version + module = PyImport_ImportModule("_xxsubinterpreters"); + if (!module) goto bad; + } + PyObject *current = PyObject_CallMethod(module, "get_current", NULL); + Py_DECREF(module); + if (!current) goto bad; + if (PyTuple_Check(current)) { + PyObject *new_current = PySequence_GetItem(current, 0); + Py_DECREF(current); + current = new_current; + if (!new_current) goto bad; + } + long long as_c_int = PyLong_AsLongLong(current); + Py_DECREF(current); + return as_c_int; + } + bad: + PySys_WriteStderr("__Pyx_GetCurrentInterpreterId failed. Try setting the C define CYTHON_PEP489_MULTI_PHASE_INIT=0\n"); + return -1; +} +#endif +#if !CYTHON_USE_MODULE_STATE +static CYTHON_SMALL_CODE int __Pyx_check_single_interpreter(void) { + static PY_INT64_T main_interpreter_id = -1; +#if CYTHON_COMPILING_IN_GRAAL + PY_INT64_T current_id = PyInterpreterState_GetIDFromThreadState(PyThreadState_Get()); +#elif CYTHON_COMPILING_IN_LIMITED_API && __PYX_LIMITED_VERSION_HEX >= 0x03090000 + PY_INT64_T current_id = PyInterpreterState_GetID(PyInterpreterState_Get()); +#elif CYTHON_COMPILING_IN_LIMITED_API + PY_INT64_T current_id = __Pyx_GetCurrentInterpreterId(); +#else + PY_INT64_T current_id = PyInterpreterState_GetID(PyThreadState_Get()->interp); +#endif + if (unlikely(current_id == -1)) { + return -1; + } + if (main_interpreter_id == -1) { + main_interpreter_id = current_id; + return 0; + } else if (unlikely(main_interpreter_id != current_id)) { + PyErr_SetString( + PyExc_ImportError, + "Interpreter change detected - this module can only be loaded into one interpreter per process."); + return -1; + } + return 0; +} +#endif +static CYTHON_SMALL_CODE int __Pyx_copy_spec_to_module(PyObject *spec, PyObject *moddict, const char* from_name, const char* to_name, int allow_none) +{ + PyObject *value = PyObject_GetAttrString(spec, from_name); + int result = 0; + if (likely(value)) { + if (allow_none || value != Py_None) { + result = PyDict_SetItemString(moddict, to_name, value); + } + Py_DECREF(value); + } else if (PyErr_ExceptionMatches(PyExc_AttributeError)) { + PyErr_Clear(); + } else { + result = -1; + } + return result; +} +static CYTHON_SMALL_CODE PyObject* __pyx_pymod_create(PyObject *spec, PyModuleDef *def) { + PyObject *module = NULL, *moddict, *modname; + CYTHON_UNUSED_VAR(def); + #if !CYTHON_USE_MODULE_STATE + if (__Pyx_check_single_interpreter()) + return NULL; + #endif + if (__pyx_m) + return __Pyx_NewRef(__pyx_m); + modname = PyObject_GetAttrString(spec, "name"); + if (unlikely(!modname)) goto bad; + module = PyModule_NewObject(modname); + Py_DECREF(modname); + if (unlikely(!module)) goto bad; + moddict = PyModule_GetDict(module); + if (unlikely(!moddict)) goto bad; + if (unlikely(__Pyx_copy_spec_to_module(spec, moddict, "loader", "__loader__", 1) < 0)) goto bad; + if (unlikely(__Pyx_copy_spec_to_module(spec, moddict, "origin", "__file__", 1) < 0)) goto bad; + if (unlikely(__Pyx_copy_spec_to_module(spec, moddict, "parent", "__package__", 1) < 0)) goto bad; + if (unlikely(__Pyx_copy_spec_to_module(spec, moddict, "submodule_search_locations", "__path__", 0) < 0)) goto bad; + return module; +bad: + Py_XDECREF(module); + return NULL; +} + + +static CYTHON_SMALL_CODE int __pyx_pymod_exec_execute_bash(PyObject *__pyx_pyinit_module) +#endif +{ + int stringtab_initialized = 0; + #if CYTHON_USE_MODULE_STATE + int pystate_addmodule_run = 0; + #endif + __pyx_mstatetype *__pyx_mstate = NULL; + PyObject *__pyx_t_1 = NULL; + PyObject *__pyx_t_2 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannyDeclarations + #if CYTHON_PEP489_MULTI_PHASE_INIT + if (__pyx_m) { + if (__pyx_m == __pyx_pyinit_module) return 0; + PyErr_SetString(PyExc_RuntimeError, "Module 'execute_bash' has already been imported. Re-initialisation is not supported."); + return -1; + } + #else + if (__pyx_m) return __Pyx_NewRef(__pyx_m); + #endif + /*--- Module creation code ---*/ + #if CYTHON_PEP489_MULTI_PHASE_INIT + __pyx_t_1 = __pyx_pyinit_module; + Py_INCREF(__pyx_t_1); + #else + __pyx_t_1 = PyModule_Create(&__pyx_moduledef); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1, __pyx_L1_error) + #endif + #if CYTHON_USE_MODULE_STATE + { + int add_module_result = __Pyx_State_AddModule(__pyx_t_1, &__pyx_moduledef); + __pyx_t_1 = 0; /* transfer ownership from __pyx_t_1 to "execute_bash" pseudovariable */ + if (unlikely((add_module_result < 0))) __PYX_ERR(0, 1, __pyx_L1_error) + pystate_addmodule_run = 1; + } + #else + __pyx_m = __pyx_t_1; + #endif + #if CYTHON_COMPILING_IN_CPYTHON_FREETHREADING + PyUnstable_Module_SetGIL(__pyx_m, Py_MOD_GIL_USED); + #endif + __pyx_mstate = __pyx_mstate_global; + CYTHON_UNUSED_VAR(__pyx_t_1); + __pyx_mstate->__pyx_d = PyModule_GetDict(__pyx_m); if (unlikely(!__pyx_mstate->__pyx_d)) __PYX_ERR(0, 1, __pyx_L1_error) + Py_INCREF(__pyx_mstate->__pyx_d); + __pyx_mstate->__pyx_b = __Pyx_PyImport_AddModuleRef(__Pyx_BUILTIN_MODULE_NAME); if (unlikely(!__pyx_mstate->__pyx_b)) __PYX_ERR(0, 1, __pyx_L1_error) + __pyx_mstate->__pyx_cython_runtime = __Pyx_PyImport_AddModuleRef("cython_runtime"); if (unlikely(!__pyx_mstate->__pyx_cython_runtime)) __PYX_ERR(0, 1, __pyx_L1_error) + if (PyObject_SetAttrString(__pyx_m, "__builtins__", __pyx_mstate->__pyx_b) < 0) __PYX_ERR(0, 1, __pyx_L1_error) + /* ImportRefnannyAPI */ + #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("PyInit_execute_bash", 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_mstate->__pyx_empty_tuple = PyTuple_New(0); if (unlikely(!__pyx_mstate->__pyx_empty_tuple)) __PYX_ERR(0, 1, __pyx_L1_error) + __pyx_mstate->__pyx_empty_bytes = PyBytes_FromStringAndSize("", 0); if (unlikely(!__pyx_mstate->__pyx_empty_bytes)) __PYX_ERR(0, 1, __pyx_L1_error) + __pyx_mstate->__pyx_empty_unicode = PyUnicode_FromStringAndSize("", 0); if (unlikely(!__pyx_mstate->__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 + /*--- Library function declarations ---*/ + /*--- Initialize various global constants etc. ---*/ + if (__Pyx_InitConstants(__pyx_mstate) < 0) __PYX_ERR(0, 1, __pyx_L1_error) + stringtab_initialized = 1; + if (__Pyx_InitGlobals() < 0) __PYX_ERR(0, 1, __pyx_L1_error) + if (__pyx_module_is_main_execute_bash) { + if (PyObject_SetAttr(__pyx_m, __pyx_mstate_global->__pyx_n_u_name, __pyx_mstate_global->__pyx_n_u_main) < 0) __PYX_ERR(0, 1, __pyx_L1_error) + } + { + PyObject *modules = PyImport_GetModuleDict(); if (unlikely(!modules)) __PYX_ERR(0, 1, __pyx_L1_error) + if (!PyDict_GetItemString(modules, "execute_bash")) { + if (unlikely((PyDict_SetItemString(modules, "execute_bash", __pyx_m) < 0))) __PYX_ERR(0, 1, __pyx_L1_error) + } + } + /*--- Builtin init code ---*/ + if (__Pyx_InitCachedBuiltins(__pyx_mstate) < 0) __PYX_ERR(0, 1, __pyx_L1_error) + /*--- Constants init code ---*/ + if (__Pyx_InitCachedConstants(__pyx_mstate) < 0) __PYX_ERR(0, 1, __pyx_L1_error) + if (__Pyx_CreateCodeObjects(__pyx_mstate) < 0) __PYX_ERR(0, 1, __pyx_L1_error) + /*--- Global type/function init code ---*/ + (void)__Pyx_modinit_global_init_code(__pyx_mstate); + (void)__Pyx_modinit_variable_export_code(__pyx_mstate); + (void)__Pyx_modinit_function_export_code(__pyx_mstate); + if (unlikely((__Pyx_modinit_type_init_code(__pyx_mstate) < 0))) __PYX_ERR(0, 1, __pyx_L1_error) + (void)__Pyx_modinit_type_import_code(__pyx_mstate); + (void)__Pyx_modinit_variable_import_code(__pyx_mstate); + (void)__Pyx_modinit_function_import_code(__pyx_mstate); + /*--- Execution code ---*/ + + /* "execute_bash.py":1 + * def _execute_bash(*args): # <<<<<<<<<<<<<< + * from re import sub + * from os import environ as hy_env +*/ + __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_12execute_bash_1_execute_bash, 0, __pyx_mstate_global->__pyx_n_u_execute_bash_2, NULL, __pyx_mstate_global->__pyx_n_u_execute_bash, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[1])); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_execute_bash_2, __pyx_t_2) < 0) __PYX_ERR(0, 1, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __pyx_t_2 = __Pyx_PyDict_NewPresized(0); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_test, __pyx_t_2) < 0) __PYX_ERR(0, 1, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + + /*--- Wrapped vars code ---*/ + + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_2); + if (__pyx_m) { + if (__pyx_mstate->__pyx_d && stringtab_initialized) { + __Pyx_AddTraceback("init execute_bash", __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 execute_bash"); + } + __pyx_L0:; + __Pyx_RefNannyFinishContext(); + #if CYTHON_PEP489_MULTI_PHASE_INIT + return (__pyx_m != NULL) ? 0 : -1; + #else + return __pyx_m; + #endif +} +/* #### Code section: pystring_table ### */ + +typedef struct { + const char *s; +#if 31 <= 65535 + const unsigned short n; +#elif 31 / 2 < INT_MAX + const unsigned int n; +#elif 31 / 2 < LONG_MAX + const unsigned long n; +#else + const Py_ssize_t n; +#endif +#if 1 <= 31 + const unsigned int encoding : 5; +#elif 1 <= 255 + const unsigned char encoding; +#elif 1 <= 65535 + const unsigned short encoding; +#else + const Py_ssize_t encoding; +#endif + const unsigned int is_unicode : 1; + const unsigned int intern : 1; +} __Pyx_StringTabEntry; +static const char * const __pyx_string_tab_encodings[] = { 0 }; +static const __Pyx_StringTabEntry __pyx_string_tab[] = { + {__pyx_k_, sizeof(__pyx_k_), 0, 1, 0}, /* PyObject cname: __pyx_kp_u_ */ + {__pyx_k_PATH, sizeof(__pyx_k_PATH), 0, 1, 1}, /* PyObject cname: __pyx_n_u_PATH */ + {__pyx_k__2, sizeof(__pyx_k__2), 0, 1, 0}, /* PyObject cname: __pyx_kp_u__2 */ + {__pyx_k__3, sizeof(__pyx_k__3), 0, 1, 0}, /* PyObject cname: __pyx_kp_u__3 */ + {__pyx_k_args, sizeof(__pyx_k_args), 0, 1, 1}, /* PyObject cname: __pyx_n_u_args */ + {__pyx_k_asyncio_coroutines, sizeof(__pyx_k_asyncio_coroutines), 0, 1, 1}, /* PyObject cname: __pyx_n_u_asyncio_coroutines */ + {__pyx_k_bin_bash, sizeof(__pyx_k_bin_bash), 0, 1, 0}, /* PyObject cname: __pyx_kp_u_bin_bash */ + {__pyx_k_check_output, sizeof(__pyx_k_check_output), 0, 1, 1}, /* PyObject cname: __pyx_n_u_check_output */ + {__pyx_k_cline_in_traceback, sizeof(__pyx_k_cline_in_traceback), 0, 1, 1}, /* PyObject cname: __pyx_n_u_cline_in_traceback */ + {__pyx_k_decode, sizeof(__pyx_k_decode), 0, 1, 1}, /* PyObject cname: __pyx_n_u_decode */ + {__pyx_k_disable, sizeof(__pyx_k_disable), 0, 1, 0}, /* PyObject cname: __pyx_kp_u_disable */ + {__pyx_k_enable, sizeof(__pyx_k_enable), 0, 1, 0}, /* PyObject cname: __pyx_kp_u_enable */ + {__pyx_k_enter, sizeof(__pyx_k_enter), 0, 1, 1}, /* PyObject cname: __pyx_n_u_enter */ + {__pyx_k_env, sizeof(__pyx_k_env), 0, 1, 1}, /* PyObject cname: __pyx_n_u_env */ + {__pyx_k_environ, sizeof(__pyx_k_environ), 0, 1, 1}, /* PyObject cname: __pyx_n_u_environ */ + {__pyx_k_executable, sizeof(__pyx_k_executable), 0, 1, 1}, /* PyObject cname: __pyx_n_u_executable */ + {__pyx_k_execute_bash, sizeof(__pyx_k_execute_bash), 0, 1, 1}, /* PyObject cname: __pyx_n_u_execute_bash */ + {__pyx_k_execute_bash_2, sizeof(__pyx_k_execute_bash_2), 0, 1, 1}, /* PyObject cname: __pyx_n_u_execute_bash_2 */ + {__pyx_k_execute_bash_execute_bash_py, sizeof(__pyx_k_execute_bash_execute_bash_py), 0, 1, 0}, /* PyObject cname: __pyx_kp_u_execute_bash_execute_bash_py */ + {__pyx_k_execute_bash_locals_lambda, sizeof(__pyx_k_execute_bash_locals_lambda), 0, 1, 1}, /* PyObject cname: __pyx_n_u_execute_bash_locals_lambda */ + {__pyx_k_exit, sizeof(__pyx_k_exit), 0, 1, 1}, /* PyObject cname: __pyx_n_u_exit */ + {__pyx_k_fp, sizeof(__pyx_k_fp), 0, 1, 1}, /* PyObject cname: __pyx_n_u_fp */ + {__pyx_k_func, sizeof(__pyx_k_func), 0, 1, 1}, /* PyObject cname: __pyx_n_u_func */ + {__pyx_k_gc, sizeof(__pyx_k_gc), 0, 1, 0}, /* PyObject cname: __pyx_kp_u_gc */ + {__pyx_k_group, sizeof(__pyx_k_group), 0, 1, 1}, /* PyObject cname: __pyx_n_u_group */ + {__pyx_k_hy_anon_var_1, sizeof(__pyx_k_hy_anon_var_1), 0, 1, 1}, /* PyObject cname: __pyx_n_u_hy_anon_var_1 */ + {__pyx_k_hy_env, sizeof(__pyx_k_hy_env), 0, 1, 1}, /* PyObject cname: __pyx_n_u_hy_env */ + {__pyx_k_is_coroutine, sizeof(__pyx_k_is_coroutine), 0, 1, 1}, /* PyObject cname: __pyx_n_u_is_coroutine */ + {__pyx_k_isenabled, sizeof(__pyx_k_isenabled), 0, 1, 0}, /* PyObject cname: __pyx_kp_u_isenabled */ + {__pyx_k_lambda, sizeof(__pyx_k_lambda), 0, 1, 1}, /* PyObject cname: __pyx_n_u_lambda */ + {__pyx_k_main, sizeof(__pyx_k_main), 0, 1, 1}, /* PyObject cname: __pyx_n_u_main */ + {__pyx_k_module, sizeof(__pyx_k_module), 0, 1, 1}, /* PyObject cname: __pyx_n_u_module */ + {__pyx_k_name, sizeof(__pyx_k_name), 0, 1, 1}, /* PyObject cname: __pyx_n_u_name */ + {__pyx_k_open, sizeof(__pyx_k_open), 0, 1, 1}, /* PyObject cname: __pyx_n_u_open */ + {__pyx_k_os, sizeof(__pyx_k_os), 0, 1, 1}, /* PyObject cname: __pyx_n_u_os */ + {__pyx_k_path, sizeof(__pyx_k_path), 0, 1, 1}, /* PyObject cname: __pyx_n_u_path */ + {__pyx_k_pop, sizeof(__pyx_k_pop), 0, 1, 1}, /* PyObject cname: __pyx_n_u_pop */ + {__pyx_k_print, sizeof(__pyx_k_print), 0, 1, 1}, /* PyObject cname: __pyx_n_u_print */ + {__pyx_k_qualname, sizeof(__pyx_k_qualname), 0, 1, 1}, /* PyObject cname: __pyx_n_u_qualname */ + {__pyx_k_r, sizeof(__pyx_k_r), 0, 1, 1}, /* PyObject cname: __pyx_n_u_r */ + {__pyx_k_re, sizeof(__pyx_k_re), 0, 1, 1}, /* PyObject cname: __pyx_n_u_re */ + {__pyx_k_read, sizeof(__pyx_k_read), 0, 1, 1}, /* PyObject cname: __pyx_n_u_read */ + {__pyx_k_scripts, sizeof(__pyx_k_scripts), 0, 1, 0}, /* PyObject cname: __pyx_kp_u_scripts */ + {__pyx_k_sequence, sizeof(__pyx_k_sequence), 0, 1, 1}, /* PyObject cname: __pyx_n_u_sequence */ + {__pyx_k_shell, sizeof(__pyx_k_shell), 0, 1, 1}, /* PyObject cname: __pyx_n_u_shell */ + {__pyx_k_strip, sizeof(__pyx_k_strip), 0, 1, 1}, /* PyObject cname: __pyx_n_u_strip */ + {__pyx_k_sub, sizeof(__pyx_k_sub), 0, 1, 1}, /* PyObject cname: __pyx_n_u_sub */ + {__pyx_k_subprocess, sizeof(__pyx_k_subprocess), 0, 1, 1}, /* PyObject cname: __pyx_n_u_subprocess */ + {__pyx_k_test, sizeof(__pyx_k_test), 0, 1, 1}, /* PyObject cname: __pyx_n_u_test */ + {0, 0, 0, 0, 0} +}; +/* InitStrings.proto */ +static int __Pyx_InitStrings(__Pyx_StringTabEntry const *t, PyObject **target, const char* const* encoding_names); + +/* #### Code section: cached_builtins ### */ + +static int __Pyx_InitCachedBuiltins(__pyx_mstatetype *__pyx_mstate) { + CYTHON_UNUSED_VAR(__pyx_mstate); + __pyx_builtin_open = __Pyx_GetBuiltinName(__pyx_mstate->__pyx_n_u_open); if (!__pyx_builtin_open) __PYX_ERR(0, 8, __pyx_L1_error) + __pyx_builtin_print = __Pyx_GetBuiltinName(__pyx_mstate->__pyx_n_u_print); if (!__pyx_builtin_print) __PYX_ERR(0, 10, __pyx_L1_error) + return 0; + __pyx_L1_error:; + return -1; +} +/* #### Code section: cached_constants ### */ + +static int __Pyx_InitCachedConstants(__pyx_mstatetype *__pyx_mstate) { + __Pyx_RefNannyDeclarations + CYTHON_UNUSED_VAR(__pyx_mstate); + __Pyx_RefNannySetupContext("__Pyx_InitCachedConstants", 0); + + /* "execute_bash.py":8 + * env['PATH'] = hy_env['PATH'] + ':./scripts' + * path = args[0] + * with open(path, 'r') as fp: # <<<<<<<<<<<<<< + * _hy_anon_var_1 = fp.read() + * print(sub('\\$\\[(.*?)\\]', lambda sequence: check_output(sequence.group(1), shell=True, executable='/bin/bash', env=env).decode().strip(), _hy_anon_var_1)) +*/ + __pyx_mstate_global->__pyx_tuple[0] = PyTuple_Pack(3, Py_None, Py_None, Py_None); if (unlikely(!__pyx_mstate_global->__pyx_tuple[0])) __PYX_ERR(0, 8, __pyx_L1_error) + __Pyx_GOTREF(__pyx_mstate_global->__pyx_tuple[0]); + __Pyx_GIVEREF(__pyx_mstate_global->__pyx_tuple[0]); + __Pyx_RefNannyFinishContext(); + return 0; + __pyx_L1_error:; + __Pyx_RefNannyFinishContext(); + return -1; +} +/* #### Code section: init_constants ### */ + +static int __Pyx_InitConstants(__pyx_mstatetype *__pyx_mstate) { + CYTHON_UNUSED_VAR(__pyx_mstate); + __pyx_mstate->__pyx_umethod_PyDict_Type_pop.type = (PyObject*)&PyDict_Type; + __pyx_mstate->__pyx_umethod_PyDict_Type_pop.method_name = &__pyx_mstate->__pyx_n_u_pop; + if (__Pyx_InitStrings(__pyx_string_tab, __pyx_mstate->__pyx_string_tab, __pyx_string_tab_encodings) < 0) __PYX_ERR(0, 1, __pyx_L1_error); + __pyx_mstate->__pyx_int_0 = PyLong_FromLong(0); if (unlikely(!__pyx_mstate->__pyx_int_0)) __PYX_ERR(0, 1, __pyx_L1_error) + __pyx_mstate->__pyx_int_1 = PyLong_FromLong(1); if (unlikely(!__pyx_mstate->__pyx_int_1)) __PYX_ERR(0, 1, __pyx_L1_error) + return 0; + __pyx_L1_error:; + return -1; +} +/* #### Code section: init_codeobjects ### */ +\ + typedef struct { + unsigned int argcount : 1; + unsigned int num_posonly_args : 1; + unsigned int num_kwonly_args : 1; + unsigned int nlocals : 4; + unsigned int flags : 10; + unsigned int first_line : 4; + unsigned int line_table_length : 11; + } __Pyx_PyCode_New_function_description; +/* NewCodeObj.proto */ +static PyObject* __Pyx_PyCode_New( + const __Pyx_PyCode_New_function_description descr, + PyObject * const *varnames, + PyObject *filename, + PyObject *funcname, + const char *line_table, + PyObject *tuple_dedup_map +); + + +static int __Pyx_CreateCodeObjects(__pyx_mstatetype *__pyx_mstate) { + PyObject* tuple_dedup_map = PyDict_New(); + if (unlikely(!tuple_dedup_map)) return -1; + { + const __Pyx_PyCode_New_function_description descr = {1, 0, 0, 1, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 10, 61}; + PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_sequence}; + __pyx_mstate_global->__pyx_codeobj_tab[0] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_execute_bash_execute_bash_py, __pyx_mstate->__pyx_n_u_lambda, __pyx_k_1_QhfATQWW_hhuuyy_E_E_G_G_M_M_N, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[0])) goto bad; + } + { + const __Pyx_PyCode_New_function_description descr = {0, 0, 0, 8, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS|CO_VARARGS), 1, 105}; + PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_args, __pyx_mstate->__pyx_n_u_sub, __pyx_mstate->__pyx_n_u_hy_env, __pyx_mstate->__pyx_n_u_check_output, __pyx_mstate->__pyx_n_u_env, __pyx_mstate->__pyx_n_u_path, __pyx_mstate->__pyx_n_u_fp, __pyx_mstate->__pyx_n_u_hy_anon_var_1}; + __pyx_mstate_global->__pyx_codeobj_tab[1] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_execute_bash_execute_bash_py, __pyx_mstate->__pyx_n_u_execute_bash_2, __pyx_k_1_1_1_q_1_4q_QfHA_5_Q_Q_Q_R_1, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[1])) goto bad; + } + Py_DECREF(tuple_dedup_map); + return 0; + bad: + Py_DECREF(tuple_dedup_map); + return -1; +} +/* #### Code section: init_globals ### */ + +static int __Pyx_InitGlobals(void) { + /* PythonCompatibility.init */ + if (likely(__Pyx_init_co_variables() == 0)); else + +if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 1, __pyx_L1_error) + + /* CachedMethodType.init */ + #if CYTHON_COMPILING_IN_LIMITED_API +{ + PyObject *typesModule=NULL; + typesModule = PyImport_ImportModule("types"); + if (typesModule) { + __pyx_mstate_global->__Pyx_CachedMethodType = PyObject_GetAttrString(typesModule, "MethodType"); + Py_DECREF(typesModule); + } +} // error handling follows +#endif + +if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 1, __pyx_L1_error) + + return 0; + __pyx_L1_error:; + return -1; +} +/* #### 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); + 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); + return PyObject_GetAttr(obj, attr_name); +} +#endif + +/* PyObjectGetAttrStrNoError */ +#if __PYX_LIMITED_VERSION_HEX < 0x030d0000 +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 >= 0x030d0000 + (void) PyObject_GetOptionalAttr(obj, attr_name, &result); + return result; +#else +#if CYTHON_COMPILING_IN_CPYTHON && CYTHON_USE_TYPE_SLOTS + 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_mstate_global->__pyx_b, name); + if (unlikely(!result) && !PyErr_Occurred()) { + PyErr_Format(PyExc_NameError, + "name '%U' is not defined", name); + } + return result; +} + +/* TupleAndListFromArray */ +#if !CYTHON_COMPILING_IN_CPYTHON && CYTHON_METH_FASTCALL +static CYTHON_INLINE PyObject * +__Pyx_PyTuple_FromArray(PyObject *const *src, Py_ssize_t n) +{ + PyObject *res; + Py_ssize_t i; + if (n <= 0) { + return __Pyx_NewRef(__pyx_mstate_global->__pyx_empty_tuple); + } + res = PyTuple_New(n); + if (unlikely(res == NULL)) return NULL; + for (i = 0; i < n; i++) { + if (unlikely(__Pyx_PyTuple_SET_ITEM(res, i, src[i]) < 0)) { + Py_DECREF(res); + return NULL; + } + Py_INCREF(src[i]); + } + return res; +} +#elif 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) { + return __Pyx_NewRef(__pyx_mstate_global->__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 || CYTHON_COMPILING_IN_GRAAL ||\ + !(CYTHON_ASSUME_SAFE_SIZE && CYTHON_ASSUME_SAFE_MACROS) + 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 || CYTHON_COMPILING_IN_GRAAL + return PyObject_RichCompareBool(s1, s2, equals); +#else + 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 (s1_is_unicode & s2_is_unicode) { + Py_ssize_t length, length2; + int kind; + void *data1, *data2; + #if !CYTHON_COMPILING_IN_LIMITED_API + if (unlikely(__Pyx_PyUnicode_READY(s1) < 0) || unlikely(__Pyx_PyUnicode_READY(s2) < 0)) + return -1; + #endif + length = __Pyx_PyUnicode_GET_LENGTH(s1); + #if !CYTHON_ASSUME_SAFE_SIZE + if (unlikely(length < 0)) return -1; + #endif + length2 = __Pyx_PyUnicode_GET_LENGTH(s2); + #if !CYTHON_ASSUME_SAFE_SIZE + if (unlikely(length2 < 0)) return -1; + #endif + if (length != length2) { + goto return_ne; + } +#if CYTHON_USE_UNICODE_INTERNALS + { + Py_hash_t hash1, hash2; + hash1 = ((PyASCIIObject*)s1)->hash; + hash2 = ((PyASCIIObject*)s2)->hash; + 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)); + 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_result) + return -1; + result = __Pyx_PyObject_IsTrue(py_result); + Py_DECREF(py_result); + return result; + } +return_eq: + return (equals == Py_EQ); +return_ne: + 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 = __Pyx_PyTuple_GET_SIZE(kwnames); + #if !CYTHON_ASSUME_SAFE_SIZE + if (unlikely(n == -1)) return NULL; + #endif + for (i = 0; i < n; i++) + { + PyObject *namei = __Pyx_PyTuple_GET_ITEM(kwnames, i); + #if !CYTHON_ASSUME_SAFE_MACROS + if (unlikely(!namei)) return NULL; + #endif + if (s == namei) return kwvalues[i]; + } + for (i = 0; i < n; i++) + { + PyObject *namei = __Pyx_PyTuple_GET_ITEM(kwnames, i); + #if !CYTHON_ASSUME_SAFE_MACROS + if (unlikely(!namei)) return NULL; + #endif + int eq = __Pyx_PyUnicode_Equals(s, namei, 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_COMPILING_IN_LIMITED_API +CYTHON_UNUSED static PyObject *__Pyx_KwargsAsDict_FASTCALL(PyObject *kwnames, PyObject *const *kwvalues) { + Py_ssize_t i, nkwargs; + PyObject *dict; +#if !CYTHON_ASSUME_SAFE_SIZE + nkwargs = PyTuple_Size(kwnames); + if (unlikely(nkwargs < 0)) return NULL; +#else + nkwargs = PyTuple_GET_SIZE(kwnames); +#endif + dict = PyDict_New(); + if (unlikely(!dict)) + return NULL; + for (i=0; irecursion_depth; + Py_DECREF(f); + --tstate->recursion_depth; + return result; +} +static PyObject *__Pyx_PyFunction_FastCallDict(PyObject *func, PyObject *const *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; + PyObject *kwdefs; + 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 (unlikely(Py_EnterRecursiveCall(" while calling a Python object"))) { + return NULL; + } + if ( + co->co_kwonlyargcount == 0 && + 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); + kwdefs = PyFunction_GET_KW_DEFAULTS(func); + if (argdefs != NULL) { + d = &PyTuple_GET_ITEM(argdefs, 0); + nd = Py_SIZE(argdefs); + } + else { + d = NULL; + nd = 0; + } + result = PyEval_EvalCodeEx((PyObject*)co, globals, (PyObject *)NULL, + args, (int)nargs, + k, (int)nk, + d, (int)nd, kwdefs, closure); + 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 (unlikely(Py_EnterRecursiveCall(" while calling a Python object"))) + return NULL; + result = (*call)(func, arg, kw); + Py_LeaveRecursiveCall(); + if (unlikely(!result) && unlikely(!PyErr_Occurred())) { + PyErr_SetString( + PyExc_SystemError, + "NULL result without error in PyObject_Call"); + } + return result; +} +#endif + +/* PyObjectCallMethO */ +#if CYTHON_COMPILING_IN_CPYTHON +static CYTHON_INLINE PyObject* __Pyx_PyObject_CallMethO(PyObject *func, PyObject *arg) { + PyObject *self, *result; + PyCFunction cfunc; + cfunc = __Pyx_CyOrPyCFunction_GET_FUNCTION(func); + self = __Pyx_CyOrPyCFunction_GET_SELF(func); + if (unlikely(Py_EnterRecursiveCall(" while calling a Python object"))) + return NULL; + result = cfunc(self, arg); + Py_LeaveRecursiveCall(); + if (unlikely(!result) && unlikely(!PyErr_Occurred())) { + PyErr_SetString( + PyExc_SystemError, + "NULL result without error in PyObject_Call"); + } + return result; +} +#endif + +/* PyObjectFastCall */ +#if PY_VERSION_HEX < 0x03090000 || CYTHON_COMPILING_IN_LIMITED_API +static PyObject* __Pyx_PyObject_FastCall_fallback(PyObject *func, PyObject * const*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 +#if CYTHON_VECTORCALL && !CYTHON_COMPILING_IN_LIMITED_API + #if PY_VERSION_HEX < 0x03090000 + #define __Pyx_PyVectorcall_Function(callable) _PyVectorcall_Function(callable) + #elif CYTHON_COMPILING_IN_CPYTHON +static CYTHON_INLINE vectorcallfunc __Pyx_PyVectorcall_Function(PyObject *callable) { + PyTypeObject *tp = Py_TYPE(callable); + #if defined(__Pyx_CyFunction_USED) + if (__Pyx_CyFunction_CheckExact(callable)) { + return __Pyx_CyFunction_func_vectorcall(callable); + } + #endif + if (!PyType_HasFeature(tp, Py_TPFLAGS_HAVE_VECTORCALL)) { + return NULL; + } + assert(PyCallable_Check(callable)); + Py_ssize_t offset = tp->tp_vectorcall_offset; + assert(offset > 0); + vectorcallfunc ptr; + memcpy(&ptr, (char *) callable + offset, sizeof(ptr)); + return ptr; +} + #else + #define __Pyx_PyVectorcall_Function(callable) PyVectorcall_Function(callable) + #endif +#endif +static CYTHON_INLINE PyObject* __Pyx_PyObject_FastCallDict(PyObject *func, PyObject *const *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 (!kwargs && __Pyx_IS_TYPE(func, &PyMethodDescr_Type)) { + return _PyMethodDescr_FastCallKeywords(func, args, nargs, NULL); + } + #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 && !CYTHON_COMPILING_IN_LIMITED_API + vectorcallfunc f = __Pyx_PyVectorcall_Function(func); + if (f) { + return f(func, args, _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, _nargs, NULL); + } + #elif CYTHON_COMPILING_IN_LIMITED_API && CYTHON_VECTORCALL + return PyObject_Vectorcall(func, args, _nargs, NULL); + #endif + } + if (nargs == 0) { + return __Pyx_PyObject_Call(func, __pyx_mstate_global->__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 +} + +/* UnpackUnboundCMethod */ +#if CYTHON_COMPILING_IN_LIMITED_API && __PYX_LIMITED_VERSION_HEX < 0x030C0000 +static PyObject *__Pyx_SelflessCall(PyObject *method, PyObject *args, PyObject *kwargs) { + PyObject *result; + PyObject *selfless_args = PyTuple_GetSlice(args, 1, PyTuple_Size(args)); + if (unlikely(!selfless_args)) return NULL; + result = PyObject_Call(method, selfless_args, kwargs); + Py_DECREF(selfless_args); + return result; +} +#elif CYTHON_COMPILING_IN_PYPY && PY_VERSION_HEX < 0x03090000 +static PyObject *__Pyx_SelflessCall(PyObject *method, PyObject **args, Py_ssize_t nargs, PyObject *kwnames) { + return _PyObject_Vectorcall + (method, args ? args+1 : NULL, nargs ? nargs-1 : 0, kwnames); +} +#else +static PyObject *__Pyx_SelflessCall(PyObject *method, PyObject *const *args, Py_ssize_t nargs, PyObject *kwnames) { + return +#if PY_VERSION_HEX < 0x03090000 + _PyObject_Vectorcall +#else + PyObject_Vectorcall +#endif + (method, args ? args+1 : NULL, nargs ? (size_t) nargs-1 : 0, kwnames); +} +#endif +static PyMethodDef __Pyx_UnboundCMethod_Def = { + "CythonUnboundCMethod", + __PYX_REINTERPRET_FUNCION(PyCFunction, __Pyx_SelflessCall), +#if CYTHON_COMPILING_IN_LIMITED_API && __PYX_LIMITED_VERSION_HEX < 0x030C0000 + METH_VARARGS | METH_KEYWORDS, +#else + METH_FASTCALL | METH_KEYWORDS, +#endif + NULL +}; +static int __Pyx_TryUnpackUnboundCMethod(__Pyx_CachedCFunction* target) { + PyObject *method, *result=NULL; + method = __Pyx_PyObject_GetAttrStr(target->type, *target->method_name); + if (unlikely(!method)) + return -1; + result = method; +#if CYTHON_COMPILING_IN_CPYTHON + if (likely(__Pyx_TypeCheck(method, &PyMethodDescr_Type))) + { + PyMethodDescrObject *descr = (PyMethodDescrObject*) method; + target->func = descr->d_method->ml_meth; + target->flag = descr->d_method->ml_flags & ~(METH_CLASS | METH_STATIC | METH_COEXIST | METH_STACKLESS); + } else +#endif +#if CYTHON_COMPILING_IN_PYPY +#else + if (PyCFunction_Check(method)) +#endif + { + PyObject *self; + int self_found; +#if CYTHON_COMPILING_IN_LIMITED_API || CYTHON_COMPILING_IN_PYPY + self = PyObject_GetAttrString(method, "__self__"); + if (!self) { + PyErr_Clear(); + } +#else + self = PyCFunction_GET_SELF(method); +#endif + self_found = (self && self != Py_None); +#if CYTHON_COMPILING_IN_LIMITED_API || CYTHON_COMPILING_IN_PYPY + Py_XDECREF(self); +#endif + if (self_found) { + PyObject *unbound_method = PyCFunction_New(&__Pyx_UnboundCMethod_Def, method); + if (unlikely(!unbound_method)) return -1; + Py_DECREF(method); + result = unbound_method; + } + } +#if !CYTHON_COMPILING_IN_CPYTHON_FREETHREADING + if (unlikely(target->method)) { + Py_DECREF(result); + } else +#endif + target->method = result; + return 0; +} + +/* CallUnboundCMethod2 */ +#if CYTHON_COMPILING_IN_CPYTHON +static CYTHON_INLINE PyObject *__Pyx_CallUnboundCMethod2(__Pyx_CachedCFunction *cfunc, PyObject *self, PyObject *arg1, PyObject *arg2) { + int was_initialized = __Pyx_CachedCFunction_GetAndSetInitializing(cfunc); + if (likely(was_initialized == 2 && cfunc->func)) { + PyObject *args[2] = {arg1, arg2}; + if (cfunc->flag == METH_FASTCALL) { + return __Pyx_CallCFunctionFast(cfunc, self, args, 2); + } + if (cfunc->flag == (METH_FASTCALL | METH_KEYWORDS)) + return __Pyx_CallCFunctionFastWithKeywords(cfunc, self, args, 2, NULL); + } +#if CYTHON_COMPILING_IN_CPYTHON_FREETHREADING + else if (unlikely(was_initialized == 1)) { + __Pyx_CachedCFunction tmp_cfunc = { +#ifndef __cplusplus + 0 +#endif + }; + tmp_cfunc.type = cfunc->type; + tmp_cfunc.method_name = cfunc->method_name; + return __Pyx__CallUnboundCMethod2(&tmp_cfunc, self, arg1, arg2); + } +#endif + PyObject *result = __Pyx__CallUnboundCMethod2(cfunc, self, arg1, arg2); + __Pyx_CachedCFunction_SetFinishedInitializing(cfunc); + return result; +} +#endif +static PyObject* __Pyx__CallUnboundCMethod2(__Pyx_CachedCFunction* cfunc, PyObject* self, PyObject* arg1, PyObject* arg2){ + if (unlikely(!cfunc->func && !cfunc->method) && unlikely(__Pyx_TryUnpackUnboundCMethod(cfunc) < 0)) return NULL; +#if CYTHON_COMPILING_IN_CPYTHON + if (cfunc->func && (cfunc->flag & METH_VARARGS)) { + PyObject *result = NULL; + PyObject *args = PyTuple_New(2); + if (unlikely(!args)) return NULL; + Py_INCREF(arg1); + PyTuple_SET_ITEM(args, 0, arg1); + Py_INCREF(arg2); + PyTuple_SET_ITEM(args, 1, arg2); + if (cfunc->flag & METH_KEYWORDS) + result = __Pyx_CallCFunctionWithKeywords(cfunc, self, args, NULL); + else + result = __Pyx_CallCFunction(cfunc, self, args); + Py_DECREF(args); + return result; + } +#endif + { + PyObject *args[4] = {NULL, self, arg1, arg2}; + return __Pyx_PyObject_FastCall(cfunc->method, args+1, 3 | __Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET); + } +} + +/* ParseKeywords */ +static int __Pyx_ValidateDuplicatePosArgs( + PyObject *kwds, + PyObject ** const argnames[], + PyObject ** const *first_kw_arg, + const char* function_name) +{ + PyObject ** const *name = argnames; + while (name != first_kw_arg) { + PyObject *key = **name; + int found = PyDict_Contains(kwds, key); + if (unlikely(found)) { + if (found == 1) __Pyx_RaiseDoubleKeywordsError(function_name, key); + goto bad; + } + name++; + } + return 0; +bad: + return -1; +} +#if CYTHON_USE_UNICODE_INTERNALS +static CYTHON_INLINE int __Pyx_UnicodeKeywordsEqual(PyObject *s1, PyObject *s2) { + int kind; + Py_ssize_t len = PyUnicode_GET_LENGTH(s1); + if (len != PyUnicode_GET_LENGTH(s2)) return 0; + kind = PyUnicode_KIND(s1); + if (kind != PyUnicode_KIND(s2)) return 0; + const void *data1 = PyUnicode_DATA(s1); + const void *data2 = PyUnicode_DATA(s2); + return (memcmp(data1, data2, (size_t) len * (size_t) kind) == 0); +} +#endif +static int __Pyx_MatchKeywordArg_str( + PyObject *key, + PyObject ** const argnames[], + PyObject ** const *first_kw_arg, + size_t *index_found, + const char *function_name) +{ + PyObject ** const *name; + #if CYTHON_USE_UNICODE_INTERNALS + Py_hash_t key_hash = ((PyASCIIObject*)key)->hash; + if (unlikely(key_hash == -1)) { + key_hash = PyObject_Hash(key); + if (unlikely(key_hash == -1)) + goto bad; + } + #endif + name = first_kw_arg; + while (*name) { + PyObject *name_str = **name; + #if CYTHON_USE_UNICODE_INTERNALS + if (key_hash == ((PyASCIIObject*)name_str)->hash && __Pyx_UnicodeKeywordsEqual(name_str, key)) { + *index_found = (size_t) (name - argnames); + return 1; + } + #else + #if CYTHON_ASSUME_SAFE_SIZE + if (PyUnicode_GET_LENGTH(name_str) == PyUnicode_GET_LENGTH(key)) + #endif + { + int cmp = PyUnicode_Compare(name_str, key); + if (cmp < 0 && unlikely(PyErr_Occurred())) goto bad; + if (cmp == 0) { + *index_found = (size_t) (name - argnames); + return 1; + } + } + #endif + name++; + } + name = argnames; + while (name != first_kw_arg) { + PyObject *name_str = **name; + #if CYTHON_USE_UNICODE_INTERNALS + if (unlikely(key_hash == ((PyASCIIObject*)name_str)->hash)) { + if (__Pyx_UnicodeKeywordsEqual(name_str, key)) + goto arg_passed_twice; + } + #else + #if CYTHON_ASSUME_SAFE_SIZE + if (PyUnicode_GET_LENGTH(name_str) == PyUnicode_GET_LENGTH(key)) + #endif + { + if (unlikely(name_str == key)) goto arg_passed_twice; + int cmp = PyUnicode_Compare(name_str, key); + if (cmp < 0 && unlikely(PyErr_Occurred())) goto bad; + if (cmp == 0) goto arg_passed_twice; + } + #endif + name++; + } + return 0; +arg_passed_twice: + __Pyx_RaiseDoubleKeywordsError(function_name, key); + goto bad; +bad: + return -1; +} +static int __Pyx_MatchKeywordArg_nostr( + PyObject *key, + PyObject ** const argnames[], + PyObject ** const *first_kw_arg, + size_t *index_found, + const char *function_name) +{ + PyObject ** const *name; + if (unlikely(!PyUnicode_Check(key))) goto invalid_keyword_type; + name = first_kw_arg; + while (*name) { + int cmp = PyObject_RichCompareBool(**name, key, Py_EQ); + if (cmp == 1) { + *index_found = (size_t) (name - argnames); + return 1; + } + if (unlikely(cmp == -1)) goto bad; + name++; + } + name = argnames; + while (name != first_kw_arg) { + int cmp = PyObject_RichCompareBool(**name, key, Py_EQ); + if (unlikely(cmp != 0)) { + if (cmp == 1) goto arg_passed_twice; + else goto bad; + } + name++; + } + 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; +bad: + return -1; +} +static CYTHON_INLINE int __Pyx_MatchKeywordArg( + PyObject *key, + PyObject ** const argnames[], + PyObject ** const *first_kw_arg, + size_t *index_found, + const char *function_name) +{ + return likely(PyUnicode_CheckExact(key)) ? + __Pyx_MatchKeywordArg_str(key, argnames, first_kw_arg, index_found, function_name) : + __Pyx_MatchKeywordArg_nostr(key, argnames, first_kw_arg, index_found, function_name); +} +static void __Pyx_RejectUnknownKeyword( + PyObject *kwds, + PyObject ** const argnames[], + PyObject ** const *first_kw_arg, + const char *function_name) +{ + Py_ssize_t pos = 0; + PyObject *key = NULL; + __Pyx_BEGIN_CRITICAL_SECTION(kwds); + while (PyDict_Next(kwds, &pos, &key, NULL)) { + PyObject** const *name = first_kw_arg; + while (*name && (**name != key)) name++; + if (!*name) { + #if CYTHON_AVOID_BORROWED_REFS + Py_INCREF(key); + #endif + size_t index_found = 0; + int cmp = __Pyx_MatchKeywordArg(key, argnames, first_kw_arg, &index_found, function_name); + if (cmp != 1) { + if (cmp == 0) { + PyErr_Format(PyExc_TypeError, + "%s() got an unexpected keyword argument '%U'", + function_name, key); + } + #if CYTHON_AVOID_BORROWED_REFS + Py_DECREF(key); + #endif + break; + } + #if CYTHON_AVOID_BORROWED_REFS + Py_DECREF(key); + #endif + } + } + __Pyx_END_CRITICAL_SECTION(); + assert(PyErr_Occurred()); +} +static int __Pyx_ParseKeywordDict( + PyObject *kwds, + PyObject ** const argnames[], + PyObject *values[], + Py_ssize_t num_pos_args, + Py_ssize_t num_kwargs, + const char* function_name, + int ignore_unknown_kwargs) +{ + PyObject** const *name; + PyObject** const *first_kw_arg = argnames + num_pos_args; + Py_ssize_t extracted = 0; +#if !CYTHON_COMPILING_IN_PYPY || defined(PyArg_ValidateKeywordArguments) + if (unlikely(!PyArg_ValidateKeywordArguments(kwds))) return -1; +#endif + name = first_kw_arg; + while (*name && num_kwargs > extracted) { + PyObject * key = **name; + PyObject *value; + int found = 0; + #if __PYX_LIMITED_VERSION_HEX >= 0x030d0000 + found = PyDict_GetItemRef(kwds, key, &value); + #else + value = PyDict_GetItemWithError(kwds, key); + if (value) { + Py_INCREF(value); + found = 1; + } else { + if (unlikely(PyErr_Occurred())) goto bad; + } + #endif + if (found) { + if (unlikely(found < 0)) goto bad; + values[name-argnames] = value; + extracted++; + } + name++; + } + if (num_kwargs > extracted) { + if (ignore_unknown_kwargs) { + if (unlikely(__Pyx_ValidateDuplicatePosArgs(kwds, argnames, first_kw_arg, function_name) == -1)) + goto bad; + } else { + __Pyx_RejectUnknownKeyword(kwds, argnames, first_kw_arg, function_name); + goto bad; + } + } + return 0; +bad: + return -1; +} +static int __Pyx_ParseKeywordDictToDict( + PyObject *kwds, + PyObject ** const argnames[], + PyObject *kwds2, + PyObject *values[], + Py_ssize_t num_pos_args, + const char* function_name) +{ + PyObject** const *name; + PyObject** const *first_kw_arg = argnames + num_pos_args; + Py_ssize_t len; +#if !CYTHON_COMPILING_IN_PYPY || defined(PyArg_ValidateKeywordArguments) + if (unlikely(!PyArg_ValidateKeywordArguments(kwds))) return -1; +#endif + if (PyDict_Update(kwds2, kwds) < 0) goto bad; + name = first_kw_arg; + while (*name) { + PyObject *key = **name; + PyObject *value; +#if !CYTHON_COMPILING_IN_LIMITED_API && (PY_VERSION_HEX >= 0x030d00A2 || defined(PyDict_Pop)) + int found = PyDict_Pop(kwds2, key, &value); + if (found) { + if (unlikely(found < 0)) goto bad; + values[name-argnames] = value; + } +#elif __PYX_LIMITED_VERSION_HEX >= 0x030d0000 + int found = PyDict_GetItemRef(kwds2, key, &value); + if (found) { + if (unlikely(found < 0)) goto bad; + values[name-argnames] = value; + if (unlikely(PyDict_DelItem(kwds2, key) < 0)) goto bad; + } +#else + #if CYTHON_COMPILING_IN_CPYTHON + value = _PyDict_Pop(kwds2, key, kwds2); + #else + value = __Pyx_CallUnboundCMethod2(&__pyx_mstate_global->__pyx_umethod_PyDict_Type_pop, kwds2, key, kwds2); + #endif + if (value == kwds2) { + Py_DECREF(value); + } else { + if (unlikely(!value)) goto bad; + values[name-argnames] = value; + } +#endif + name++; + } + len = PyDict_Size(kwds2); + if (len > 0) { + return __Pyx_ValidateDuplicatePosArgs(kwds, argnames, first_kw_arg, function_name); + } else if (unlikely(len == -1)) { + goto bad; + } + return 0; +bad: + return -1; +} +static int __Pyx_ParseKeywordsTuple( + PyObject *kwds, + PyObject * const *kwvalues, + PyObject ** const argnames[], + PyObject *kwds2, + PyObject *values[], + Py_ssize_t num_pos_args, + Py_ssize_t num_kwargs, + const char* function_name, + int ignore_unknown_kwargs) +{ + PyObject *key = NULL; + PyObject** const * name; + PyObject** const *first_kw_arg = argnames + num_pos_args; + for (Py_ssize_t pos = 0; pos < num_kwargs; pos++) { +#if CYTHON_AVOID_BORROWED_REFS + key = __Pyx_PySequence_ITEM(kwds, pos); +#else + key = __Pyx_PyTuple_GET_ITEM(kwds, pos); +#endif +#if !CYTHON_ASSUME_SAFE_MACROS + if (unlikely(!key)) goto bad; +#endif + name = first_kw_arg; + while (*name && (**name != key)) name++; + if (*name) { + PyObject *value = kwvalues[pos]; + values[name-argnames] = __Pyx_NewRef(value); + } else { + size_t index_found = 0; + int cmp = __Pyx_MatchKeywordArg(key, argnames, first_kw_arg, &index_found, function_name); + if (cmp == 1) { + PyObject *value = kwvalues[pos]; + values[index_found] = __Pyx_NewRef(value); + } else { + if (unlikely(cmp == -1)) goto bad; + if (kwds2) { + PyObject *value = kwvalues[pos]; + if (unlikely(PyDict_SetItem(kwds2, key, value))) goto bad; + } else if (!ignore_unknown_kwargs) { + goto invalid_keyword; + } + } + } + #if CYTHON_AVOID_BORROWED_REFS + Py_DECREF(key); + key = NULL; + #endif + } + return 0; +invalid_keyword: + PyErr_Format(PyExc_TypeError, + "%s() got an unexpected keyword argument '%U'", + function_name, key); + goto bad; +bad: + #if CYTHON_AVOID_BORROWED_REFS + Py_XDECREF(key); + #endif + return -1; +} +static int __Pyx_ParseKeywords( + PyObject *kwds, + PyObject * const *kwvalues, + PyObject ** const argnames[], + PyObject *kwds2, + PyObject *values[], + Py_ssize_t num_pos_args, + Py_ssize_t num_kwargs, + const char* function_name, + int ignore_unknown_kwargs) +{ + if (CYTHON_METH_FASTCALL && likely(PyTuple_Check(kwds))) + return __Pyx_ParseKeywordsTuple(kwds, kwvalues, argnames, kwds2, values, num_pos_args, num_kwargs, function_name, ignore_unknown_kwargs); + else if (kwds2) + return __Pyx_ParseKeywordDictToDict(kwds, argnames, kwds2, values, num_pos_args, function_name); + else + return __Pyx_ParseKeywordDict(kwds, argnames, values, num_pos_args, num_kwargs, function_name, ignore_unknown_kwargs); +} + +/* RaiseArgTupleInvalid */ +static void __Pyx_RaiseArgtupleInvalid( + const char* func_name, + int exact, + Py_ssize_t num_min, + Py_ssize_t num_max, + Py_ssize_t num_found) +{ + Py_ssize_t num_expected; + const char *more_or_less; + if (num_found < num_min) { + num_expected = num_min; + more_or_less = "at least"; + } else { + num_expected = num_max; + more_or_less = "at most"; + } + if (exact) { + more_or_less = "exactly"; + } + PyErr_Format(PyExc_TypeError, + "%.200s() takes %.8s %" CYTHON_FORMAT_SSIZE_T "d positional argument%.1s (%" CYTHON_FORMAT_SSIZE_T "d given)", + func_name, more_or_less, num_expected, + (num_expected == 1) ? "" : "s", num_found); +} + +/* RaiseClosureNameError */ +static void __Pyx_RaiseClosureNameError(const char *varname) { + PyErr_Format(PyExc_NameError, "free variable '%s' referenced before assignment in enclosing scope", varname); +} + +/* PyObjectFastCallMethod */ +#if !CYTHON_VECTORCALL || PY_VERSION_HEX < 0x03090000 +static PyObject *__Pyx_PyObject_FastCallMethod(PyObject *name, PyObject *const *args, size_t nargsf) { + PyObject *result; + PyObject *attr = PyObject_GetAttr(args[0], name); + if (unlikely(!attr)) + return NULL; + result = __Pyx_PyObject_FastCall(attr, args+1, nargsf - 1); + Py_DECREF(attr); + return result; +} +#endif + +/* PyObjectVectorCallKwBuilder */ +#if CYTHON_VECTORCALL +static int __Pyx_VectorcallBuilder_AddArg(PyObject *key, PyObject *value, PyObject *builder, PyObject **args, int n) { + (void)__Pyx_PyObject_FastCallDict; + if (__Pyx_PyTuple_SET_ITEM(builder, n, key) != (0)) return -1; + Py_INCREF(key); + args[n] = value; + return 0; +} +CYTHON_UNUSED static int __Pyx_VectorcallBuilder_AddArg_Check(PyObject *key, PyObject *value, PyObject *builder, PyObject **args, int n) { + (void)__Pyx_VectorcallBuilder_AddArgStr; + if (unlikely(!PyUnicode_Check(key))) { + PyErr_SetString(PyExc_TypeError, "keywords must be strings"); + return -1; + } + return __Pyx_VectorcallBuilder_AddArg(key, value, builder, args, n); +} +static int __Pyx_VectorcallBuilder_AddArgStr(const char *key, PyObject *value, PyObject *builder, PyObject **args, int n) { + PyObject *pyKey = PyUnicode_FromString(key); + if (!pyKey) return -1; + return __Pyx_VectorcallBuilder_AddArg(pyKey, value, builder, args, n); +} +#else // CYTHON_VECTORCALL +CYTHON_UNUSED static int __Pyx_VectorcallBuilder_AddArg_Check(PyObject *key, PyObject *value, PyObject *builder, CYTHON_UNUSED PyObject **args, CYTHON_UNUSED int n) { + if (unlikely(!PyUnicode_Check(key))) { + PyErr_SetString(PyExc_TypeError, "keywords must be strings"); + return -1; + } + return PyDict_SetItem(builder, key, value); +} +#endif + +/* Import */ +static PyObject *__Pyx_Import(PyObject *name, PyObject *from_list, int level) { + PyObject *module = 0; + PyObject *empty_dict = 0; + PyObject *empty_list = 0; + empty_dict = PyDict_New(); + if (unlikely(!empty_dict)) + goto bad; + if (level == -1) { + const char* package_sep = strchr(__Pyx_MODULE_NAME, '.'); + if (package_sep != (0)) { + module = PyImport_ImportModuleLevelObject( + name, __pyx_mstate_global->__pyx_d, empty_dict, from_list, 1); + if (unlikely(!module)) { + if (unlikely(!PyErr_ExceptionMatches(PyExc_ImportError))) + goto bad; + PyErr_Clear(); + } + } + level = 0; + } + if (!module) { + module = PyImport_ImportModuleLevelObject( + name, __pyx_mstate_global->__pyx_d, empty_dict, from_list, level); + } +bad: + Py_XDECREF(empty_dict); + Py_XDECREF(empty_list); + return module; +} + +/* ImportFrom */ +static PyObject* __Pyx_ImportFrom(PyObject* module, PyObject* name) { + PyObject* value = __Pyx_PyObject_GetAttrStr(module, name); + if (unlikely(!value) && PyErr_ExceptionMatches(PyExc_AttributeError)) { + 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_mstate_global->__pyx_kp_u_); + if (unlikely(!module_dot)) { goto modbad; } + full_name = PyUnicode_Concat(module_dot, name); + if (unlikely(!full_name)) { goto modbad; } + #if (CYTHON_COMPILING_IN_PYPY && PYPY_VERSION_NUM < 0x07030400) ||\ + CYTHON_COMPILING_IN_GRAAL + { + 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, "cannot import name %S", name); + } + return value; +} + +/* DictGetItem */ +#if !CYTHON_COMPILING_IN_PYPY +static PyObject *__Pyx_PyDict_GetItem(PyObject *d, PyObject* key) { + PyObject *value; + if (unlikely(__Pyx_PyDict_GetItemRef(d, key, &value) == 0)) { // no value, no error + if (unlikely(PyTuple_Check(key))) { + PyObject* args = PyTuple_Pack(1, key); + if (likely(args)) { + PyErr_SetObject(PyExc_KeyError, args); + Py_DECREF(args); + } + } else { + PyErr_SetObject(PyExc_KeyError, key); + } + } + return value; +} +#endif + +/* 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_ASSUME_SAFE_SIZE && !CYTHON_AVOID_BORROWED_REFS && !CYTHON_AVOID_THREAD_UNSAFE_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, PyLong_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_ASSUME_SAFE_SIZE && !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, PyLong_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_ASSUME_SAFE_SIZE && !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))))) { + return __Pyx_PyList_GetItemRef(o, n); + } + } + 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 = PyLong_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, PyLong_FromSsize_t(i)); +} + +/* PyObjectLookupSpecial */ +#if CYTHON_USE_PYTYPE_LOOKUP && CYTHON_USE_TYPE_SLOTS +static CYTHON_INLINE PyObject* __Pyx__PyObject_LookupSpecial(PyObject* obj, PyObject* attr_name, int with_error) { + PyObject *res; + PyTypeObject *tp = Py_TYPE(obj); + res = _PyType_Lookup(tp, attr_name); + if (likely(res)) { + descrgetfunc f = Py_TYPE(res)->tp_descr_get; + if (!f) { + Py_INCREF(res); + } else { + res = f(res, obj, (PyObject *)tp); + } + } else if (with_error) { + PyErr_SetObject(PyExc_AttributeError, attr_name); + } + return res; +} +#endif + +/* 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 >= 0x030C0000 + local_value = tstate->current_exception; + tstate->current_exception = 0; + #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 +#elif __PYX_LIMITED_VERSION_HEX > 0x030C0000 + local_value = PyErr_GetRaisedException(); +#else + PyErr_Fetch(&local_type, &local_value, &local_tb); +#endif +#if __PYX_LIMITED_VERSION_HEX > 0x030C0000 + if (likely(local_value)) { + local_type = (PyObject*) Py_TYPE(local_value); + Py_INCREF(local_type); + local_tb = PyException_GetTraceback(local_value); + } +#else + PyErr_NormalizeException(&local_type, &local_value, &local_tb); +#if CYTHON_FAST_THREAD_STATE + if (unlikely(tstate->curexc_type)) +#else + if (unlikely(PyErr_Occurred())) +#endif + goto bad; + if (local_tb) { + if (unlikely(PyException_SetTraceback(local_value, local_tb) < 0)) + goto bad; + } +#endif // __PYX_LIMITED_VERSION_HEX > 0x030C0000 + 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); +#elif __PYX_LIMITED_VERSION_HEX >= 0x030b0000 + PyErr_SetHandledException(local_value); + Py_XDECREF(local_value); + Py_XDECREF(local_type); + Py_XDECREF(local_tb); +#else + PyErr_SetExcInfo(local_type, local_value, local_tb); +#endif + return 0; +#if __PYX_LIMITED_VERSION_HEX <= 0x030C0000 +bad: + *type = 0; + *value = 0; + *tb = 0; + Py_XDECREF(local_type); + Py_XDECREF(local_value); + Py_XDECREF(local_tb); + return -1; +#endif +} + +/* FixUpExtensionType */ +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; +} + +/* FetchSharedCythonModule */ +static PyObject *__Pyx_FetchSharedCythonABIModule(void) { + return __Pyx_PyImport_AddModuleRef(__PYX_ABI_MODULE_NAME); +} + +/* dict_setdefault */ +static CYTHON_INLINE PyObject *__Pyx_PyDict_SetDefault(PyObject *d, PyObject *key, PyObject *default_value, + int is_safe_type) { + PyObject* value; + CYTHON_MAYBE_UNUSED_VAR(is_safe_type); +#if CYTHON_COMPILING_IN_LIMITED_API + value = PyObject_CallMethod(d, "setdefault", "OO", key, default_value); +#elif PY_VERSION_HEX >= 0x030d0000 + PyDict_SetDefaultRef(d, key, default_value, &value); +#else + value = PyDict_SetDefault(d, key, default_value); + if (unlikely(!value)) return NULL; + Py_INCREF(value); +#endif + return value; +} + +/* FetchCommonType */ +static int __Pyx_VerifyCachedType(PyObject *cached_type, + const char *name, + Py_ssize_t expected_basicsize) { + Py_ssize_t basicsize; + if (!PyType_Check(cached_type)) { + PyErr_Format(PyExc_TypeError, + "Shared Cython type %.200s is not a type object", name); + return -1; + } +#if CYTHON_COMPILING_IN_LIMITED_API + PyObject *py_basicsize; + py_basicsize = PyObject_GetAttrString(cached_type, "__basicsize__"); + if (unlikely(!py_basicsize)) return -1; + basicsize = PyLong_AsSsize_t(py_basicsize); + Py_DECREF(py_basicsize); + py_basicsize = NULL; + if (unlikely(basicsize == (Py_ssize_t)-1) && PyErr_Occurred()) return -1; +#else + basicsize = ((PyTypeObject*) cached_type)->tp_basicsize; +#endif + if (basicsize != expected_basicsize) { + PyErr_Format(PyExc_TypeError, + "Shared Cython type %.200s has the wrong size, try recompiling", + name); + return -1; + } + return 0; +} +static PyTypeObject *__Pyx_FetchCommonTypeFromSpec(PyObject *module, PyType_Spec *spec, PyObject *bases) { + PyObject *abi_module = NULL, *cached_type = NULL, *abi_module_dict, *new_cached_type, *py_object_name; + int get_item_ref_result; + const char* object_name = strrchr(spec->name, '.'); + object_name = object_name ? object_name+1 : spec->name; + py_object_name = PyUnicode_FromString(object_name); + if (!py_object_name) return NULL; + abi_module = __Pyx_FetchSharedCythonABIModule(); + if (!abi_module) goto done; + abi_module_dict = PyModule_GetDict(abi_module); + if (!abi_module_dict) goto done; + get_item_ref_result = __Pyx_PyDict_GetItemRef(abi_module_dict, py_object_name, &cached_type); + if (get_item_ref_result == 1) { + if (__Pyx_VerifyCachedType( + cached_type, + object_name, + spec->basicsize) < 0) { + goto bad; + } + goto done; + } else if (unlikely(get_item_ref_result == -1)) { + goto bad; + } + 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; + new_cached_type = __Pyx_PyDict_SetDefault(abi_module_dict, py_object_name, cached_type, 1); + if (unlikely(new_cached_type != cached_type)) { + if (unlikely(!new_cached_type)) goto bad; + Py_DECREF(cached_type); + cached_type = new_cached_type; + if (__Pyx_VerifyCachedType( + cached_type, + object_name, + spec->basicsize) < 0) { + goto bad; + } + goto done; + } else { + Py_DECREF(new_cached_type); + } +done: + Py_XDECREF(abi_module); + Py_DECREF(py_object_name); + assert(cached_type == NULL || PyType_Check(cached_type)); + return (PyTypeObject *) cached_type; +bad: + Py_XDECREF(cached_type); + cached_type = NULL; + goto done; +} + +/* CallTypeTraverse */ +#if !CYTHON_USE_TYPE_SPECS || (!CYTHON_COMPILING_IN_LIMITED_API && PY_VERSION_HEX < 0x03090000) +#else +static int __Pyx_call_type_traverse(PyObject *o, int always_call, visitproc visit, void *arg) { + #if CYTHON_COMPILING_IN_LIMITED_API && __PYX_LIMITED_VERSION_HEX < 0x03090000 + if (__Pyx_get_runtime_version() < 0x03090000) return 0; + #endif + if (!always_call) { + PyTypeObject *base = __Pyx_PyObject_GetSlot(o, tp_base, PyTypeObject*); + unsigned long flags = PyType_GetFlags(base); + if (flags & Py_TPFLAGS_HEAPTYPE) { + return 0; + } + } + Py_VISIT((PyObject*)Py_TYPE(o)); + return 0; +} +#endif + +/* PyMethodNew */ +#if CYTHON_COMPILING_IN_LIMITED_API +static PyObject *__Pyx_PyMethod_New(PyObject *func, PyObject *self, PyObject *typ) { + PyObject *result; + CYTHON_UNUSED_VAR(typ); + if (!self) + return __Pyx_NewRef(func); + #if __PYX_LIMITED_VERSION_HEX >= 0x030C0000 + { + PyObject *args[] = {func, self}; + result = PyObject_Vectorcall(__pyx_mstate_global->__Pyx_CachedMethodType, args, 2, NULL); + } + #else + result = PyObject_CallFunctionObjArgs(__pyx_mstate_global->__Pyx_CachedMethodType, func, self, NULL); + #endif + return result; +} +#else +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); +} +#endif + +/* PyVectorcallFastCallDict */ +#if CYTHON_METH_FASTCALL && (CYTHON_VECTORCALL || CYTHON_BACKPORT_VECTORCALL) +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; + #if !CYTHON_ASSUME_SAFE_SIZE + Py_ssize_t nkw = PyDict_Size(kw); + if (unlikely(nkw == -1)) return NULL; + #else + Py_ssize_t nkw = PyDict_GET_SIZE(kw); + #endif + 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 &= + #if CYTHON_COMPILING_IN_LIMITED_API + PyType_GetFlags(Py_TYPE(key)); + #else + Py_TYPE(key)->tp_flags; + #endif + Py_INCREF(key); + Py_INCREF(value); + #if !CYTHON_ASSUME_SAFE_MACROS + if (unlikely(PyTuple_SetItem(kwnames, i, key) < 0)) goto cleanup; + #else + PyTuple_SET_ITEM(kwnames, i, key); + #endif + 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) +{ + Py_ssize_t kw_size = + likely(kw == NULL) ? + 0 : +#if !CYTHON_ASSUME_SAFE_SIZE + PyDict_Size(kw); +#else + PyDict_GET_SIZE(kw); +#endif + if (kw_size == 0) { + return vc(func, args, nargs, NULL); + } +#if !CYTHON_ASSUME_SAFE_SIZE + else if (unlikely(kw_size == -1)) { + return NULL; + } +#endif + return __Pyx_PyVectorcall_FastCallDict_kw(func, vc, args, nargs, kw); +} +#endif + +/* CythonFunctionShared */ +#if CYTHON_COMPILING_IN_LIMITED_API +static CYTHON_INLINE int __Pyx__IsSameCyOrCFunctionNoMethod(PyObject *func, void (*cfunc)(void)) { + 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; +} +static CYTHON_INLINE int __Pyx__IsSameCyOrCFunction(PyObject *func, void (*cfunc)(void)) { + if ((PyObject*)Py_TYPE(func) == __pyx_mstate_global->__Pyx_CachedMethodType) { + int result; + PyObject *newFunc = PyObject_GetAttr(func, __pyx_mstate_global->__pyx_n_u_func); + if (unlikely(!newFunc)) { + PyErr_Clear(); // It's only an optimization, so don't throw an error + return 0; + } + result = __Pyx__IsSameCyOrCFunctionNoMethod(newFunc, cfunc); + Py_DECREF(newFunc); + return result; + } + return __Pyx__IsSameCyOrCFunctionNoMethod(func, cfunc); +} +#else +static CYTHON_INLINE int __Pyx__IsSameCyOrCFunction(PyObject *func, void (*cfunc)(void)) { + if (PyMethod_Check(func)) { + func = PyMethod_GET_FUNCTION(func); + } + 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_locked(__pyx_CyFunctionObject *op) +{ + 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) { + op->func_doc = PyUnicode_FromString(((PyCFunctionObject*)op)->m_ml->ml_doc); + 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 PyObject * +__Pyx_CyFunction_get_doc(__pyx_CyFunctionObject *op, void *closure) { + PyObject *result; + CYTHON_UNUSED_VAR(closure); + __Pyx_BEGIN_CRITICAL_SECTION(op); + result = __Pyx_CyFunction_get_doc_locked(op); + __Pyx_END_CRITICAL_SECTION(); + return result; +} +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_BEGIN_CRITICAL_SECTION(op); + __Pyx_Py_XDECREF_SET(op->func_doc, value); + __Pyx_END_CRITICAL_SECTION(); + return 0; +} +static PyObject * +__Pyx_CyFunction_get_name_locked(__pyx_CyFunctionObject *op) +{ + if (unlikely(op->func_name == NULL)) { +#if CYTHON_COMPILING_IN_LIMITED_API + op->func_name = PyObject_GetAttrString(op->func, "__name__"); +#else + op->func_name = PyUnicode_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 PyObject * +__Pyx_CyFunction_get_name(__pyx_CyFunctionObject *op, void *context) +{ + PyObject *result = NULL; + CYTHON_UNUSED_VAR(context); + __Pyx_BEGIN_CRITICAL_SECTION(op); + result = __Pyx_CyFunction_get_name_locked(op); + __Pyx_END_CRITICAL_SECTION(); + return result; +} +static int +__Pyx_CyFunction_set_name(__pyx_CyFunctionObject *op, PyObject *value, void *context) +{ + CYTHON_UNUSED_VAR(context); + if (unlikely(value == NULL || !PyUnicode_Check(value))) { + PyErr_SetString(PyExc_TypeError, + "__name__ must be set to a string object"); + return -1; + } + Py_INCREF(value); + __Pyx_BEGIN_CRITICAL_SECTION(op); + __Pyx_Py_XDECREF_SET(op->func_name, value); + __Pyx_END_CRITICAL_SECTION(); + return 0; +} +static PyObject * +__Pyx_CyFunction_get_qualname(__pyx_CyFunctionObject *op, void *context) +{ + CYTHON_UNUSED_VAR(context); + PyObject *result; + __Pyx_BEGIN_CRITICAL_SECTION(op); + Py_INCREF(op->func_qualname); + result = op->func_qualname; + __Pyx_END_CRITICAL_SECTION(); + return result; +} +static int +__Pyx_CyFunction_set_qualname(__pyx_CyFunctionObject *op, PyObject *value, void *context) +{ + CYTHON_UNUSED_VAR(context); + if (unlikely(value == NULL || !PyUnicode_Check(value))) { + PyErr_SetString(PyExc_TypeError, + "__qualname__ must be set to a string object"); + return -1; + } + Py_INCREF(value); + __Pyx_BEGIN_CRITICAL_SECTION(op); + __Pyx_Py_XDECREF_SET(op->func_qualname, value); + __Pyx_END_CRITICAL_SECTION(); + return 0; +} +static PyObject * +__Pyx_CyFunction_get_dict_locked(__pyx_CyFunctionObject *op) +{ + 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 PyObject * +__Pyx_CyFunction_get_dict(__pyx_CyFunctionObject *op, void *context) +{ + CYTHON_UNUSED_VAR(context); + PyObject *result; + __Pyx_BEGIN_CRITICAL_SECTION(op); + result = __Pyx_CyFunction_get_dict_locked(op); + __Pyx_END_CRITICAL_SECTION(); + return result; +} +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_BEGIN_CRITICAL_SECTION(op); + __Pyx_Py_XDECREF_SET(op->func_dict, value); + __Pyx_END_CRITICAL_SECTION(); + 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_BEGIN_CRITICAL_SECTION(op); + __Pyx_Py_XDECREF_SET(op->defaults_tuple, value); + __Pyx_END_CRITICAL_SECTION(); + return 0; +} +static PyObject * +__Pyx_CyFunction_get_defaults_locked(__pyx_CyFunctionObject *op) { + PyObject* result = op->defaults_tuple; + 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 PyObject * +__Pyx_CyFunction_get_defaults(__pyx_CyFunctionObject *op, void *context) { + PyObject* result = NULL; + CYTHON_UNUSED_VAR(context); + __Pyx_BEGIN_CRITICAL_SECTION(op); + result = __Pyx_CyFunction_get_defaults_locked(op); + __Pyx_END_CRITICAL_SECTION(); + 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_BEGIN_CRITICAL_SECTION(op); + __Pyx_Py_XDECREF_SET(op->defaults_kwdict, value); + __Pyx_END_CRITICAL_SECTION(); + return 0; +} +static PyObject * +__Pyx_CyFunction_get_kwdefaults_locked(__pyx_CyFunctionObject *op) { + PyObject* result = op->defaults_kwdict; + 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 PyObject * +__Pyx_CyFunction_get_kwdefaults(__pyx_CyFunctionObject *op, void *context) { + PyObject* result; + CYTHON_UNUSED_VAR(context); + __Pyx_BEGIN_CRITICAL_SECTION(op); + result = __Pyx_CyFunction_get_kwdefaults_locked(op); + __Pyx_END_CRITICAL_SECTION(); + 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_BEGIN_CRITICAL_SECTION(op); + __Pyx_Py_XDECREF_SET(op->func_annotations, value); + __Pyx_END_CRITICAL_SECTION(); + return 0; +} +static PyObject * +__Pyx_CyFunction_get_annotations_locked(__pyx_CyFunctionObject *op) { + PyObject* result = op->func_annotations; + if (unlikely(!result)) { + result = PyDict_New(); + if (unlikely(!result)) return NULL; + op->func_annotations = result; + } + Py_INCREF(result); + return result; +} +static PyObject * +__Pyx_CyFunction_get_annotations(__pyx_CyFunctionObject *op, void *context) { + PyObject *result; + CYTHON_UNUSED_VAR(context); + __Pyx_BEGIN_CRITICAL_SECTION(op); + result = __Pyx_CyFunction_get_annotations_locked(op); + __Pyx_END_CRITICAL_SECTION(); + return result; +} +static PyObject * +__Pyx_CyFunction_get_is_coroutine_value(__pyx_CyFunctionObject *op) { + int is_coroutine = op->flags & __Pyx_CYFUNCTION_COROUTINE; + if (is_coroutine) { + PyObject *is_coroutine_value, *module, *fromlist, *marker = __pyx_mstate_global->__pyx_n_u_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_mstate_global->__pyx_n_u_asyncio_coroutines, NULL, NULL, fromlist, 0); + Py_DECREF(fromlist); + if (unlikely(!module)) goto ignore; + is_coroutine_value = __Pyx_PyObject_GetAttrStr(module, marker); + Py_DECREF(module); + if (likely(is_coroutine_value)) { + return is_coroutine_value; + } +ignore: + PyErr_Clear(); + } + return __Pyx_PyBool_FromLong(is_coroutine); +} +static PyObject * +__Pyx_CyFunction_get_is_coroutine(__pyx_CyFunctionObject *op, void *context) { + PyObject *result; + CYTHON_UNUSED_VAR(context); + if (op->func_is_coroutine) { + return __Pyx_NewRef(op->func_is_coroutine); + } + result = __Pyx_CyFunction_get_is_coroutine_value(op); + if (unlikely(!result)) + return NULL; + __Pyx_BEGIN_CRITICAL_SECTION(op); + if (op->func_is_coroutine) { + Py_DECREF(result); + result = __Pyx_NewRef(op->func_is_coroutine); + } else { + op->func_is_coroutine = __Pyx_NewRef(result); + } + __Pyx_END_CRITICAL_SECTION(); + return result; +} +static void __Pyx_CyFunction_raise_argument_count_error(__pyx_CyFunctionObject *func, const char* message, Py_ssize_t size) { +#if CYTHON_COMPILING_IN_LIMITED_API + PyObject *py_name = __Pyx_CyFunction_get_name(func, NULL); + if (!py_name) return; + PyErr_Format(PyExc_TypeError, + "%.200S() %s (%" CYTHON_FORMAT_SSIZE_T "d given)", + py_name, message, size); + Py_DECREF(py_name); +#else + const char* name = ((PyCFunctionObject*)func)->m_ml->ml_name; + PyErr_Format(PyExc_TypeError, + "%.200s() %s (%" CYTHON_FORMAT_SSIZE_T "d given)", + name, message, size); +#endif +} +static void __Pyx_CyFunction_raise_type_error(__pyx_CyFunctionObject *func, const char* message) { +#if CYTHON_COMPILING_IN_LIMITED_API + PyObject *py_name = __Pyx_CyFunction_get_name(func, NULL); + if (!py_name) return; + PyErr_Format(PyExc_TypeError, + "%.200S() %s", + py_name, message); + Py_DECREF(py_name); +#else + const char* name = ((PyCFunctionObject*)func)->m_ml->ml_name; + PyErr_Format(PyExc_TypeError, + "%.200s() %s", + name, message); +#endif +} +#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[] = { + {"func_doc", (getter)__Pyx_CyFunction_get_doc, (setter)__Pyx_CyFunction_set_doc, 0, 0}, + {"__doc__", (getter)__Pyx_CyFunction_get_doc, (setter)__Pyx_CyFunction_set_doc, 0, 0}, + {"func_name", (getter)__Pyx_CyFunction_get_name, (setter)__Pyx_CyFunction_set_name, 0, 0}, + {"__name__", (getter)__Pyx_CyFunction_get_name, (setter)__Pyx_CyFunction_set_name, 0, 0}, + {"__qualname__", (getter)__Pyx_CyFunction_get_qualname, (setter)__Pyx_CyFunction_set_qualname, 0, 0}, + {"func_dict", (getter)__Pyx_CyFunction_get_dict, (setter)__Pyx_CyFunction_set_dict, 0, 0}, + {"__dict__", (getter)__Pyx_CyFunction_get_dict, (setter)__Pyx_CyFunction_set_dict, 0, 0}, + {"func_globals", (getter)__Pyx_CyFunction_get_globals, 0, 0, 0}, + {"__globals__", (getter)__Pyx_CyFunction_get_globals, 0, 0, 0}, + {"func_closure", (getter)__Pyx_CyFunction_get_closure, 0, 0, 0}, + {"__closure__", (getter)__Pyx_CyFunction_get_closure, 0, 0, 0}, + {"func_code", (getter)__Pyx_CyFunction_get_code, 0, 0, 0}, + {"__code__", (getter)__Pyx_CyFunction_get_code, 0, 0, 0}, + {"func_defaults", (getter)__Pyx_CyFunction_get_defaults, (setter)__Pyx_CyFunction_set_defaults, 0, 0}, + {"__defaults__", (getter)__Pyx_CyFunction_get_defaults, (setter)__Pyx_CyFunction_set_defaults, 0, 0}, + {"__kwdefaults__", (getter)__Pyx_CyFunction_get_kwdefaults, (setter)__Pyx_CyFunction_set_kwdefaults, 0, 0}, + {"__annotations__", (getter)__Pyx_CyFunction_get_annotations, (setter)__Pyx_CyFunction_set_annotations, 0, 0}, + {"_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 + {"__module__", T_OBJECT, offsetof(PyCFunctionObject, m_module), 0, 0}, +#endif + {"__dictoffset__", T_PYSSIZET, offsetof(__pyx_CyFunctionObject, func_dict), READONLY, 0}, +#if CYTHON_METH_FASTCALL +#if CYTHON_BACKPORT_VECTORCALL || CYTHON_COMPILING_IN_LIMITED_API + {"__vectorcalloffset__", T_PYSSIZET, offsetof(__pyx_CyFunctionObject, func_vectorcall), READONLY, 0}, +#else + {"__vectorcalloffset__", T_PYSSIZET, offsetof(PyCFunctionObject, vectorcall), READONLY, 0}, +#endif +#if CYTHON_COMPILING_IN_LIMITED_API + {"__weaklistoffset__", T_PYSSIZET, offsetof(__pyx_CyFunctionObject, func_weakreflist), READONLY, 0}, +#else + {"__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) +{ + PyObject *result = NULL; + CYTHON_UNUSED_VAR(args); + __Pyx_BEGIN_CRITICAL_SECTION(m); + Py_INCREF(m->func_qualname); + result = m->func_qualname; + __Pyx_END_CRITICAL_SECTION(); + return result; +} +static PyMethodDef __pyx_CyFunction_methods[] = { + {"__reduce__", (PyCFunction)__Pyx_CyFunction_reduce, METH_VARARGS, 0}, + {0, 0, 0, 0} +}; +#if 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 = 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); + Py_CLEAR(m->defaults); + 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) +{ + { + int e = __Pyx_call_type_traverse((PyObject*)m, 1, visit, arg); + if (e) return e; + } + 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); + __Pyx_VISIT_CONST(m->func_name); + __Pyx_VISIT_CONST(m->func_qualname); + Py_VISIT(m->func_doc); + Py_VISIT(m->func_globals); + __Pyx_VISIT_CONST(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); + Py_VISIT(m->defaults); + return 0; +} +static PyObject* +__Pyx_CyFunction_repr(__pyx_CyFunctionObject *op) +{ + PyObject *repr; + __Pyx_BEGIN_CRITICAL_SECTION(op); + repr = PyUnicode_FromFormat("", + op->func_qualname, (void *)op); + __Pyx_END_CRITICAL_SECTION(); + return repr; +} +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; + 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(*)(void))meth)(self, arg, kw); + case METH_NOARGS: + if (likely(kw == NULL || PyDict_Size(kw) == 0)) { +#if CYTHON_ASSUME_SAFE_SIZE + 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); + __Pyx_CyFunction_raise_argument_count_error( + (__pyx_CyFunctionObject*)func, + "takes no arguments", size); + return NULL; + } + break; + case METH_O: + if (likely(kw == NULL || PyDict_Size(kw) == 0)) { +#if CYTHON_ASSUME_SAFE_SIZE + 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; + } + __Pyx_CyFunction_raise_argument_count_error( + (__pyx_CyFunctionObject*)func, + "takes exactly one argument", size); + return NULL; + } + break; + default: + PyErr_SetString(PyExc_SystemError, "Bad call flags for CyFunction"); + return NULL; + } + __Pyx_CyFunction_raise_type_error( + (__pyx_CyFunctionObject*)func, "takes no keyword arguments"); + 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 && (CYTHON_VECTORCALL || CYTHON_BACKPORT_VECTORCALL) + __pyx_vectorcallfunc vc = __Pyx_CyFunction_func_vectorcall(cyfunc); + if (vc) { +#if CYTHON_ASSUME_SAFE_MACROS && CYTHON_ASSUME_SAFE_SIZE + 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_SIZE + 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); + PyErr_Format(PyExc_TypeError, + "unbound method %.200S() needs an argument", + cyfunc->func_qualname); + return NULL; + } + result = __Pyx_CyFunction_CallMethod(func, self, new_args, kw); + Py_DECREF(new_args); + } else { + result = __Pyx_CyFunction_Call(func, args, kw); + } + return result; +} +#if CYTHON_METH_FASTCALL && (CYTHON_VECTORCALL || CYTHON_BACKPORT_VECTORCALL) +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)) { + __Pyx_CyFunction_raise_type_error( + cyfunc, "needs an argument"); + return -1; + } + ret = 1; + } + if (unlikely(kwnames) && unlikely(__Pyx_PyTuple_GET_SIZE(kwnames))) { + __Pyx_CyFunction_raise_type_error( + cyfunc, "takes no keyword arguments"); + 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; +#if CYTHON_BACKPORT_VECTORCALL + Py_ssize_t nargs = (Py_ssize_t)nargsf; +#else + Py_ssize_t nargs = PyVectorcall_NARGS(nargsf); +#endif + PyObject *self; +#if CYTHON_COMPILING_IN_LIMITED_API + PyCFunction meth = PyCFunction_GetFunction(cyfunc->func); + if (unlikely(!meth)) return NULL; +#else + PyCFunction meth = ((PyCFunctionObject*)cyfunc)->m_ml->ml_meth; +#endif + switch (__Pyx_CyFunction_Vectorcall_CheckArgs(cyfunc, nargs, kwnames)) { + case 1: + self = args[0]; + args += 1; + nargs -= 1; + break; + case 0: +#if CYTHON_COMPILING_IN_LIMITED_API + self = PyCFunction_GetSelf(((__pyx_CyFunctionObject*)cyfunc)->func); + if (unlikely(!self) && PyErr_Occurred()) return NULL; +#else + self = ((PyCFunctionObject*)cyfunc)->m_self; +#endif + break; + default: + return NULL; + } + if (unlikely(nargs != 0)) { + __Pyx_CyFunction_raise_argument_count_error( + cyfunc, "takes no arguments", nargs); + return NULL; + } + return 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; +#if CYTHON_BACKPORT_VECTORCALL + Py_ssize_t nargs = (Py_ssize_t)nargsf; +#else + Py_ssize_t nargs = PyVectorcall_NARGS(nargsf); +#endif + PyObject *self; +#if CYTHON_COMPILING_IN_LIMITED_API + PyCFunction meth = PyCFunction_GetFunction(cyfunc->func); + if (unlikely(!meth)) return NULL; +#else + PyCFunction meth = ((PyCFunctionObject*)cyfunc)->m_ml->ml_meth; +#endif + switch (__Pyx_CyFunction_Vectorcall_CheckArgs(cyfunc, nargs, kwnames)) { + case 1: + self = args[0]; + args += 1; + nargs -= 1; + break; + case 0: +#if CYTHON_COMPILING_IN_LIMITED_API + self = PyCFunction_GetSelf(((__pyx_CyFunctionObject*)cyfunc)->func); + if (unlikely(!self) && PyErr_Occurred()) return NULL; +#else + self = ((PyCFunctionObject*)cyfunc)->m_self; +#endif + break; + default: + return NULL; + } + if (unlikely(nargs != 1)) { + __Pyx_CyFunction_raise_argument_count_error( + cyfunc, "takes exactly one argument", nargs); + return NULL; + } + return 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; +#if CYTHON_BACKPORT_VECTORCALL + Py_ssize_t nargs = (Py_ssize_t)nargsf; +#else + Py_ssize_t nargs = PyVectorcall_NARGS(nargsf); +#endif + PyObject *self; +#if CYTHON_COMPILING_IN_LIMITED_API + PyCFunction meth = PyCFunction_GetFunction(cyfunc->func); + if (unlikely(!meth)) return NULL; +#else + PyCFunction meth = ((PyCFunctionObject*)cyfunc)->m_ml->ml_meth; +#endif + switch (__Pyx_CyFunction_Vectorcall_CheckArgs(cyfunc, nargs, NULL)) { + case 1: + self = args[0]; + args += 1; + nargs -= 1; + break; + case 0: +#if CYTHON_COMPILING_IN_LIMITED_API + self = PyCFunction_GetSelf(((__pyx_CyFunctionObject*)cyfunc)->func); + if (unlikely(!self) && PyErr_Occurred()) return NULL; +#else + self = ((PyCFunctionObject*)cyfunc)->m_self; +#endif + break; + default: + return NULL; + } + return ((__Pyx_PyCFunctionFastWithKeywords)(void(*)(void))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; + 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; +#if CYTHON_COMPILING_IN_LIMITED_API + PyCFunction meth = PyCFunction_GetFunction(cyfunc->func); + if (unlikely(!meth)) return NULL; +#else + PyCFunction meth = ((PyCFunctionObject*)cyfunc)->m_ml->ml_meth; +#endif + switch (__Pyx_CyFunction_Vectorcall_CheckArgs(cyfunc, nargs, NULL)) { + case 1: + self = args[0]; + args += 1; + nargs -= 1; + break; + case 0: +#if CYTHON_COMPILING_IN_LIMITED_API + self = PyCFunction_GetSelf(((__pyx_CyFunctionObject*)cyfunc)->func); + if (unlikely(!self) && PyErr_Occurred()) return NULL; +#else + self = ((PyCFunctionObject*)cyfunc)->m_self; +#endif + break; + default: + return NULL; + } + return ((__Pyx_PyCMethod)(void(*)(void))meth)(self, cls, args, (size_t)nargs, kwnames); +} +#endif +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 CYTHON_METH_FASTCALL +#if defined(Py_TPFLAGS_HAVE_VECTORCALL) + Py_TPFLAGS_HAVE_VECTORCALL | +#elif defined(_Py_TPFLAGS_HAVE_VECTORCALL) + _Py_TPFLAGS_HAVE_VECTORCALL | +#endif +#endif // CYTHON_METH_FASTCALL +#if PY_VERSION_HEX >= 0x030A0000 + Py_TPFLAGS_IMMUTABLETYPE | +#endif + Py_TPFLAGS_DEFAULT | Py_TPFLAGS_HAVE_GC | Py_TPFLAGS_BASETYPE, + __pyx_CyFunctionType_slots +}; +static int __pyx_CyFunction_init(PyObject *module) { + __pyx_mstatetype *mstate = __Pyx_PyModule_GetState(module); + mstate->__pyx_CyFunctionType = __Pyx_FetchCommonTypeFromSpec(module, &__pyx_CyFunctionType_spec, NULL); + if (unlikely(mstate->__pyx_CyFunctionType == NULL)) { + return -1; + } + return 0; +} +static CYTHON_INLINE PyObject *__Pyx_CyFunction_InitDefaults(PyObject *func, PyTypeObject *defaults_type) { + __pyx_CyFunctionObject *m = (__pyx_CyFunctionObject *) func; + m->defaults = PyObject_CallObject((PyObject*)defaults_type, NULL); // _PyObject_New(defaults_type); + if (unlikely(!m->defaults)) + return NULL; + 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_mstate_global->__pyx_CyFunctionType), + ml, flags, qualname, closure, module, globals, code + ); + if (likely(op)) { + PyObject_GC_Track(op); + } + return op; +} + +/* RaiseUnboundLocalError */ +static void __Pyx_RaiseUnboundLocalError(const char *varname) { + PyErr_Format(PyExc_UnboundLocalError, "local variable '%s' referenced before assignment", varname); +} + +/* 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); +} + +/* 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); +} + +/* 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)) +#else + #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 +#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_GetFullyQualifiedName(tp); + PyErr_Format(PyExc_AttributeError, + "'" __Pyx_FMT_TYPENAME "' object has no attribute '%U'", + type_name, name); + __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_SIZE + n = PyTuple_GET_SIZE(bases); +#else + n = PyTuple_Size(bases); + if (unlikely(n < 0)) return -1; +#endif + for (i = 1; i < n; i++) + { + PyTypeObject *b; +#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 + b = (PyTypeObject*) b0; + if (!__Pyx_PyType_HasFeature(b, Py_TPFLAGS_HEAPTYPE)) + { + __Pyx_TypeName b_name = __Pyx_PyType_GetFullyQualifiedName(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 + 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_GetFullyQualifiedName(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 + 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 */ +CYTHON_UNUSED static int __Pyx_PyType_HasMultipleInheritance(PyTypeObject *t) { + while (t) { + PyObject *bases = __Pyx_PyType_GetSlot(t, tp_bases, PyObject*); + if (bases) { + return 1; + } + t = __Pyx_PyType_GetSlot(t, tp_base, PyTypeObject*); + } + return 0; +} +static int __Pyx_PyType_Ready(PyTypeObject *t) { +#if CYTHON_USE_TYPE_SPECS || !CYTHON_COMPILING_IN_CPYTHON || 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; + if (!__Pyx_PyType_HasMultipleInheritance(t)) { + return PyType_Ready(t); + } + 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 !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 (!CYTHON_COMPILING_IN_PYPY || PYPY_VERSION_NUM+0 >= 0x07030400) &&\ + !CYTHON_COMPILING_IN_GRAAL + gc = PyImport_GetModule(__pyx_mstate_global->__pyx_kp_u_gc); + #endif + if (unlikely(!gc)) gc = PyImport_Import(__pyx_mstate_global->__pyx_kp_u_gc); + if (unlikely(!gc)) return -1; + py_status = __Pyx_PyObject_CallMethod0(gc, __pyx_mstate_global->__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_mstate_global->__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 !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_mstate_global->__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 +} + +/* 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 + +/* CLineInTraceback */ +#if CYTHON_CLINE_IN_TRACEBACK && CYTHON_CLINE_IN_TRACEBACK_RUNTIME +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_mstate_global->__pyx_cython_runtime)) { + return c_line; + } + __Pyx_ErrFetchInState(tstate, &ptype, &pvalue, &ptraceback); +#if CYTHON_COMPILING_IN_CPYTHON + cython_runtime_dict = _PyObject_GetDictPtr(__pyx_mstate_global->__pyx_cython_runtime); + if (likely(cython_runtime_dict)) { + __Pyx_BEGIN_CRITICAL_SECTION(*cython_runtime_dict); + __PYX_PY_DICT_LOOKUP_IF_MODIFIED( + use_cline, *cython_runtime_dict, + __Pyx_PyDict_GetItemStr(*cython_runtime_dict, __pyx_mstate_global->__pyx_n_u_cline_in_traceback)) + Py_XINCREF(use_cline); + __Pyx_END_CRITICAL_SECTION(); + } else +#endif + { + PyObject *use_cline_obj = __Pyx_PyObject_GetAttrStrNoError(__pyx_mstate_global->__pyx_cython_runtime, __pyx_mstate_global->__pyx_n_u_cline_in_traceback); + if (use_cline_obj) { + use_cline = PyObject_Not(use_cline_obj) ? Py_False : Py_True; + Py_INCREF(use_cline); + Py_DECREF(use_cline_obj); + } else { + PyErr_Clear(); + use_cline = NULL; + } + } + if (!use_cline) { + c_line = 0; + (void) PyObject_SetAttr(__pyx_mstate_global->__pyx_cython_runtime, __pyx_mstate_global->__pyx_n_u_cline_in_traceback, Py_False); + } + else if (use_cline == Py_False || (use_cline != Py_True && PyObject_Not(use_cline) != 0)) { + c_line = 0; + } + Py_XDECREF(use_cline); + __Pyx_ErrRestoreInState(tstate, ptype, pvalue, ptraceback); + return c_line; +} +#endif + +/* CodeObjectCache */ +static int __pyx_bisect_code_objects(__Pyx_CodeObjectCacheEntry* entries, int count, int code_line) { + int start = 0, mid = 0, end = count - 1; + if (end >= 0 && code_line > entries[end].code_line) { + return count; + } + while (start < end) { + mid = start + (end - start) / 2; + if (code_line < entries[mid].code_line) { + end = mid; + } else if (code_line > entries[mid].code_line) { + start = mid + 1; + } else { + return mid; + } + } + if (code_line <= entries[mid].code_line) { + return mid; + } else { + return mid + 1; + } +} +static __Pyx_CachedCodeObjectType *__pyx__find_code_object(struct __Pyx_CodeObjectCache *code_cache, int code_line) { + __Pyx_CachedCodeObjectType* code_object; + int pos; + if (unlikely(!code_line) || unlikely(!code_cache->entries)) { + return NULL; + } + pos = __pyx_bisect_code_objects(code_cache->entries, code_cache->count, code_line); + if (unlikely(pos >= code_cache->count) || unlikely(code_cache->entries[pos].code_line != code_line)) { + return NULL; + } + code_object = code_cache->entries[pos].code_object; + Py_INCREF(code_object); + return code_object; +} +static __Pyx_CachedCodeObjectType *__pyx_find_code_object(int code_line) { +#if CYTHON_COMPILING_IN_CPYTHON_FREETHREADING && !CYTHON_ATOMICS + (void)__pyx__find_code_object; + return NULL; // Most implementation should have atomics. But otherwise, don't make it thread-safe, just miss. +#else + struct __Pyx_CodeObjectCache *code_cache = &__pyx_mstate_global->__pyx_code_cache; +#if CYTHON_COMPILING_IN_CPYTHON_FREETHREADING + __pyx_nonatomic_int_type old_count = __pyx_atomic_incr_acq_rel(&code_cache->accessor_count); + if (old_count < 0) { + __pyx_atomic_decr_acq_rel(&code_cache->accessor_count); + return NULL; + } +#endif + __Pyx_CachedCodeObjectType *result = __pyx__find_code_object(code_cache, code_line); +#if CYTHON_COMPILING_IN_CPYTHON_FREETHREADING + __pyx_atomic_decr_acq_rel(&code_cache->accessor_count); +#endif + return result; +#endif +} +static void __pyx__insert_code_object(struct __Pyx_CodeObjectCache *code_cache, int code_line, __Pyx_CachedCodeObjectType* code_object) +{ + int pos, i; + __Pyx_CodeObjectCacheEntry* entries = code_cache->entries; + if (unlikely(!code_line)) { + return; + } + if (unlikely(!entries)) { + entries = (__Pyx_CodeObjectCacheEntry*)PyMem_Malloc(64*sizeof(__Pyx_CodeObjectCacheEntry)); + if (likely(entries)) { + code_cache->entries = entries; + code_cache->max_count = 64; + 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(code_cache->entries, code_cache->count, code_line); + if ((pos < code_cache->count) && unlikely(code_cache->entries[pos].code_line == code_line)) { + __Pyx_CachedCodeObjectType* tmp = entries[pos].code_object; + entries[pos].code_object = code_object; + Py_INCREF(code_object); + Py_DECREF(tmp); + return; + } + if (code_cache->count == code_cache->max_count) { + int new_max = code_cache->max_count + 64; + entries = (__Pyx_CodeObjectCacheEntry*)PyMem_Realloc( + code_cache->entries, ((size_t)new_max) * sizeof(__Pyx_CodeObjectCacheEntry)); + if (unlikely(!entries)) { + return; + } + code_cache->entries = entries; + code_cache->max_count = new_max; + } + for (i=code_cache->count; i>pos; i--) { + entries[i] = entries[i-1]; + } + entries[pos].code_line = code_line; + entries[pos].code_object = code_object; + code_cache->count++; + Py_INCREF(code_object); +} +static void __pyx_insert_code_object(int code_line, __Pyx_CachedCodeObjectType* code_object) { +#if CYTHON_COMPILING_IN_CPYTHON_FREETHREADING && !CYTHON_ATOMICS + (void)__pyx__insert_code_object; + return; // Most implementation should have atomics. But otherwise, don't make it thread-safe, just fail. +#else + struct __Pyx_CodeObjectCache *code_cache = &__pyx_mstate_global->__pyx_code_cache; +#if CYTHON_COMPILING_IN_CPYTHON_FREETHREADING + __pyx_nonatomic_int_type expected = 0; + if (!__pyx_atomic_int_cmp_exchange(&code_cache->accessor_count, &expected, INT_MIN)) { + return; + } +#endif + __pyx__insert_code_object(code_cache, code_line, code_object); +#if CYTHON_COMPILING_IN_CPYTHON_FREETHREADING + __pyx_atomic_sub(&code_cache->accessor_count, INT_MIN); +#endif +#endif +} + +/* AddTraceback */ +#include "compile.h" +#include "frameobject.h" +#include "traceback.h" +#if PY_VERSION_HEX >= 0x030b00a6 && !CYTHON_COMPILING_IN_LIMITED_API && !defined(PYPY_VERSION) + #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 = PyObject_Call(replace, __pyx_mstate_global->__pyx_empty_tuple, scratch_dict); + Py_DECREF(replace); + return result; + } + PyErr_Clear(); + return NULL; +} +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 = __pyx_find_code_object(c_line ? -c_line : py_line); + if (!code_object) { + 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; + __pyx_insert_code_object(c_line ? -c_line : py_line, code_object); + } else { + dict = PyDict_New(); + } + 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 (c_line) { + 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; + } + py_code = PyCode_NewEmpty(filename, funcname, py_line); + Py_XDECREF(py_funcname); + return py_code; +bad: + Py_XDECREF(py_funcname); + 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_mstate_global->__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 + +/* CIntToPy */ +static CYTHON_INLINE PyObject* __Pyx_PyLong_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 PyLong_FromLong((long) value); + } else if (sizeof(long) <= sizeof(unsigned long)) { + return PyLong_FromUnsignedLong((unsigned long) value); +#if defined(HAVE_LONG_LONG) && !CYTHON_COMPILING_IN_PYPY + } 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 PyLong_FromLong((long) value); +#ifdef HAVE_LONG_LONG + } else if (sizeof(long) <= sizeof(PY_LONG_LONG)) { + return PyLong_FromLongLong((PY_LONG_LONG) value); +#endif + } + } + { + unsigned char *bytes = (unsigned char *)&value; +#if !CYTHON_COMPILING_IN_LIMITED_API && PY_VERSION_HEX >= 0x030d00A4 + if (is_unsigned) { + return PyLong_FromUnsignedNativeBytes(bytes, sizeof(value), -1); + } else { + return PyLong_FromNativeBytes(bytes, sizeof(value), -1); + } +#elif !CYTHON_COMPILING_IN_LIMITED_API && PY_VERSION_HEX < 0x030d0000 + int one = 1; int little = (int)*(unsigned char *)&one; + return _PyLong_FromByteArray(bytes, sizeof(long), + little, !is_unsigned); +#else + int one = 1; int little = (int)*(unsigned char *)&one; + PyObject *from_bytes, *result = NULL, *kwds = NULL; + PyObject *py_bytes = 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; + { + PyObject *args[3+(CYTHON_VECTORCALL ? 1 : 0)] = { NULL, py_bytes, order_str }; + if (!is_unsigned) { + kwds = __Pyx_MakeVectorcallBuilderKwds(1); + if (!kwds) goto limited_bad; + if (__Pyx_VectorcallBuilder_AddArgStr("signed", __Pyx_NewRef(Py_True), kwds, args+3, 0) < 0) goto limited_bad; + } + result = __Pyx_Object_Vectorcall_CallFromBuilder(from_bytes, args+1, 2 | __Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET, kwds); + } + limited_bad: + Py_XDECREF(kwds); + Py_XDECREF(order_str); + Py_XDECREF(py_bytes); + Py_XDECREF(from_bytes); + return result; +#endif + } +} + +/* FormatTypeName */ +#if CYTHON_COMPILING_IN_LIMITED_API && __PYX_LIMITED_VERSION_HEX < 0x030d0000 +static __Pyx_TypeName +__Pyx_PyType_GetFullyQualifiedName(PyTypeObject* tp) +{ + PyObject *module = NULL, *name = NULL, *result = NULL; + #if __PYX_LIMITED_VERSION_HEX < 0x030b0000 + name = __Pyx_PyObject_GetAttrStr((PyObject *)tp, + __pyx_mstate_global->__pyx_n_u_qualname); + #else + name = PyType_GetQualName(tp); + #endif + if (unlikely(name == NULL) || unlikely(!PyUnicode_Check(name))) goto bad; + module = __Pyx_PyObject_GetAttrStr((PyObject *)tp, + __pyx_mstate_global->__pyx_n_u_module); + if (unlikely(module == NULL) || unlikely(!PyUnicode_Check(module))) goto bad; + if (PyUnicode_CompareWithASCIIString(module, "builtins") == 0) { + result = name; + name = NULL; + goto done; + } + result = PyUnicode_FromFormat("%U.%U", module, name); + if (unlikely(result == NULL)) goto bad; + done: + Py_XDECREF(name); + Py_XDECREF(module); + return result; + bad: + PyErr_Clear(); + if (name) { + result = name; + name = NULL; + } else { + result = __Pyx_NewRef(__pyx_mstate_global->__pyx_kp_u__3); + } + goto done; +} +#endif + +/* CIntFromPyVerify */ +#define __PYX_VERIFY_RETURN_INT(target_type, func_type, func_value)\ + __PYX__VERIFY_RETURN_INT(target_type, func_type, func_value, 0) +#define __PYX_VERIFY_RETURN_INT_EXC(target_type, func_type, func_value)\ + __PYX__VERIFY_RETURN_INT(target_type, func_type, func_value, 1) +#define __PYX__VERIFY_RETURN_INT(target_type, func_type, func_value, exc)\ + {\ + func_type value = func_value;\ + if (sizeof(target_type) < sizeof(func_type)) {\ + if (unlikely(value != (func_type) (target_type) value)) {\ + func_type zero = 0;\ + if (exc && unlikely(value == (func_type)-1 && PyErr_Occurred()))\ + return (target_type) -1;\ + if (is_unsigned && unlikely(value < zero))\ + goto raise_neg_overflow;\ + else\ + goto raise_overflow;\ + }\ + }\ + return (target_type) value;\ + } + +/* CIntFromPy */ +static CYTHON_INLINE long __Pyx_PyLong_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 (unlikely(!PyLong_Check(x))) { + long val; + PyObject *tmp = __Pyx_PyNumber_Long(x); + if (!tmp) return (long) -1; + val = __Pyx_PyLong_As_long(tmp); + Py_DECREF(tmp); + return val; + } + 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; + int ret = -1; +#if PY_VERSION_HEX >= 0x030d00A6 && !CYTHON_COMPILING_IN_LIMITED_API + Py_ssize_t bytes_copied = PyLong_AsNativeBytes( + x, &val, sizeof(val), Py_ASNATIVEBYTES_NATIVE_ENDIAN | (is_unsigned ? Py_ASNATIVEBYTES_UNSIGNED_BUFFER | Py_ASNATIVEBYTES_REJECT_NEGATIVE : 0)); + if (unlikely(bytes_copied == -1)) { + } else if (unlikely(bytes_copied > (Py_ssize_t) sizeof(val))) { + goto raise_overflow; + } else { + ret = 0; + } +#elif 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 *)x, + bytes, sizeof(val), + is_little, !is_unsigned); +#else + PyObject *v; + PyObject *stepval = NULL, *mask = NULL, *shift = NULL; + int bits, remaining_bits, is_negative = 0; + int chunk_size = (sizeof(long) < 8) ? 30 : 62; + if (likely(PyLong_CheckExact(x))) { + v = __Pyx_NewRef(x); + } else { + v = PyNumber_Long(x); + if (unlikely(!v)) return (long) -1; + assert(PyLong_CheckExact(v)); + } + { + int result = PyObject_RichCompareBool(v, Py_False, Py_LT); + if (unlikely(result < 0)) { + Py_DECREF(v); + return (long) -1; + } + is_negative = result == 1; + } + if (is_unsigned && unlikely(is_negative)) { + Py_DECREF(v); + goto raise_neg_overflow; + } else if (is_negative) { + stepval = PyNumber_Invert(v); + Py_DECREF(v); + if (unlikely(!stepval)) + return (long) -1; + } else { + stepval = v; + } + v = NULL; + 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; + long idigit; + digit = PyNumber_And(stepval, mask); + if (unlikely(!digit)) goto done; + idigit = PyLong_AsLong(digit); + Py_DECREF(digit); + if (unlikely(idigit < 0)) goto done; + val |= ((long) idigit) << bits; + tmp = PyNumber_Rshift(stepval, shift); + if (unlikely(!tmp)) goto done; + Py_DECREF(stepval); stepval = tmp; + } + Py_DECREF(shift); shift = NULL; + Py_DECREF(mask); mask = NULL; + { + long 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 (!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 + if (unlikely(ret)) + return (long) -1; + return val; + } +raise_overflow: + PyErr_SetString(PyExc_OverflowError, + "value too large to convert to long"); + return (long) -1; +raise_neg_overflow: + PyErr_SetString(PyExc_OverflowError, + "can't convert negative value to long"); + return (long) -1; +} + +/* CIntFromPy */ +static CYTHON_INLINE int __Pyx_PyLong_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 (unlikely(!PyLong_Check(x))) { + int val; + PyObject *tmp = __Pyx_PyNumber_Long(x); + if (!tmp) return (int) -1; + val = __Pyx_PyLong_As_int(tmp); + Py_DECREF(tmp); + return val; + } + 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; + int ret = -1; +#if PY_VERSION_HEX >= 0x030d00A6 && !CYTHON_COMPILING_IN_LIMITED_API + Py_ssize_t bytes_copied = PyLong_AsNativeBytes( + x, &val, sizeof(val), Py_ASNATIVEBYTES_NATIVE_ENDIAN | (is_unsigned ? Py_ASNATIVEBYTES_UNSIGNED_BUFFER | Py_ASNATIVEBYTES_REJECT_NEGATIVE : 0)); + if (unlikely(bytes_copied == -1)) { + } else if (unlikely(bytes_copied > (Py_ssize_t) sizeof(val))) { + goto raise_overflow; + } else { + ret = 0; + } +#elif 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 *)x, + bytes, sizeof(val), + is_little, !is_unsigned); +#else + PyObject *v; + PyObject *stepval = NULL, *mask = NULL, *shift = NULL; + int bits, remaining_bits, is_negative = 0; + int chunk_size = (sizeof(long) < 8) ? 30 : 62; + if (likely(PyLong_CheckExact(x))) { + v = __Pyx_NewRef(x); + } else { + v = PyNumber_Long(x); + if (unlikely(!v)) return (int) -1; + assert(PyLong_CheckExact(v)); + } + { + int result = PyObject_RichCompareBool(v, Py_False, Py_LT); + if (unlikely(result < 0)) { + Py_DECREF(v); + return (int) -1; + } + is_negative = result == 1; + } + if (is_unsigned && unlikely(is_negative)) { + Py_DECREF(v); + goto raise_neg_overflow; + } else if (is_negative) { + stepval = PyNumber_Invert(v); + Py_DECREF(v); + if (unlikely(!stepval)) + return (int) -1; + } else { + stepval = v; + } + v = NULL; + 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; + long idigit; + digit = PyNumber_And(stepval, mask); + if (unlikely(!digit)) goto done; + idigit = PyLong_AsLong(digit); + Py_DECREF(digit); + if (unlikely(idigit < 0)) goto done; + val |= ((int) idigit) << bits; + tmp = PyNumber_Rshift(stepval, shift); + if (unlikely(!tmp)) goto done; + Py_DECREF(stepval); stepval = tmp; + } + Py_DECREF(shift); shift = NULL; + Py_DECREF(mask); mask = NULL; + { + long 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 (!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 + if (unlikely(ret)) + return (int) -1; + return val; + } +raise_overflow: + PyErr_SetString(PyExc_OverflowError, + "value too large to convert to int"); + return (int) -1; +raise_neg_overflow: + PyErr_SetString(PyExc_OverflowError, + "can't convert negative value to int"); + return (int) -1; +} + +/* FastTypeChecks */ +#if CYTHON_COMPILING_IN_CPYTHON +static int __Pyx_InBases(PyTypeObject *a, PyTypeObject *b) { + while (a) { + a = __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); +} +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); + } +} +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); + for (i=0; i= 0x030b0000 + return Py_Version & ~0xFFUL; +#else + static unsigned long __Pyx_cached_runtime_version = 0; + if (__Pyx_cached_runtime_version == 0) { + 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; + } + __Pyx_cached_runtime_version = version; + } + return __Pyx_cached_runtime_version; +#endif +} + +/* CheckBinaryVersion */ +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); + } +} + +/* NewCodeObj */ +#if CYTHON_COMPILING_IN_LIMITED_API + static 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, "iiiiiOOOOOOiOOO", 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, "iiiiiiOOOOOOiOOO", 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, "iiiiiiOOOOOOOiOOOO", 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; + } +#elif PY_VERSION_HEX >= 0x030B0000 + static 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; + 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, __pyx_mstate_global->__pyx_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 +static PyObject* __Pyx_PyCode_New( + const __Pyx_PyCode_New_function_description descr, + PyObject * const *varnames, + PyObject *filename, + PyObject *funcname, + const char *line_table, + PyObject *tuple_dedup_map +) { + PyObject *code_obj = NULL, *varnames_tuple_dedup = NULL, *code_bytes = NULL, *line_table_bytes = NULL; + Py_ssize_t var_count = (Py_ssize_t) descr.nlocals; + PyObject *varnames_tuple = PyTuple_New(var_count); + if (unlikely(!varnames_tuple)) return NULL; + for (Py_ssize_t i=0; i < var_count; i++) { + Py_INCREF(varnames[i]); + if (__Pyx_PyTuple_SET_ITEM(varnames_tuple, i, varnames[i]) != (0)) goto done; + } + #if CYTHON_COMPILING_IN_LIMITED_API + varnames_tuple_dedup = PyDict_GetItem(tuple_dedup_map, varnames_tuple); + if (!varnames_tuple_dedup) { + if (unlikely(PyDict_SetItem(tuple_dedup_map, varnames_tuple, varnames_tuple) < 0)) goto done; + varnames_tuple_dedup = varnames_tuple; + } + #else + varnames_tuple_dedup = PyDict_SetDefault(tuple_dedup_map, varnames_tuple, varnames_tuple); + if (unlikely(!varnames_tuple_dedup)) goto done; + #endif + #if CYTHON_AVOID_BORROWED_REFS + Py_INCREF(varnames_tuple_dedup); + #endif + if (__PYX_LIMITED_VERSION_HEX >= (0x030b0000) && line_table != NULL + && !CYTHON_COMPILING_IN_GRAAL) { + line_table_bytes = PyBytes_FromStringAndSize(line_table, descr.line_table_length); + if (unlikely(!line_table_bytes)) goto done; + Py_ssize_t code_len = (descr.line_table_length * 2 + 4) & ~3; + code_bytes = PyBytes_FromStringAndSize(NULL, code_len); + if (unlikely(!code_bytes)) goto done; + char* c_code_bytes = PyBytes_AsString(code_bytes); + if (unlikely(!c_code_bytes)) goto done; + memset(c_code_bytes, 0, (size_t) code_len); + } + code_obj = (PyObject*) __Pyx__PyCode_New( + (int) descr.argcount, + (int) descr.num_posonly_args, + (int) descr.num_kwonly_args, + (int) descr.nlocals, + 0, + (int) descr.flags, + code_bytes ? code_bytes : __pyx_mstate_global->__pyx_empty_bytes, + __pyx_mstate_global->__pyx_empty_tuple, + __pyx_mstate_global->__pyx_empty_tuple, + varnames_tuple_dedup, + __pyx_mstate_global->__pyx_empty_tuple, + __pyx_mstate_global->__pyx_empty_tuple, + filename, + funcname, + (int) descr.first_line, + (__PYX_LIMITED_VERSION_HEX >= (0x030b0000) && line_table_bytes) ? line_table_bytes : __pyx_mstate_global->__pyx_empty_bytes + ); +done: + Py_XDECREF(code_bytes); + Py_XDECREF(line_table_bytes); + #if CYTHON_AVOID_BORROWED_REFS + Py_XDECREF(varnames_tuple_dedup); + #endif + Py_DECREF(varnames_tuple); + return code_obj; +} + +/* InitStrings */ +static int __Pyx_InitStrings(__Pyx_StringTabEntry const *t, PyObject **target, const char* const* encoding_names) { + while (t->s) { + PyObject *str; + if (t->is_unicode) { + if (t->intern) { + str = PyUnicode_InternFromString(t->s); + } else if (t->encoding) { + str = PyUnicode_Decode(t->s, t->n - 1, encoding_names[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; + *target = str; + if (PyObject_Hash(str) == -1) + return -1; + ++t; + ++target; + } + 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_UTF8 +static CYTHON_INLINE const char* __Pyx_PyUnicode_AsStringAndSize(PyObject* o, Py_ssize_t *length) { + if (unlikely(__Pyx_PyUnicode_READY(o) == -1)) return NULL; +#if CYTHON_COMPILING_IN_LIMITED_API + { + const char* result; + Py_ssize_t unicode_length; + CYTHON_MAYBE_UNUSED_VAR(unicode_length); // only for __PYX_DEFAULT_STRING_ENCODING_IS_ASCII + #if __PYX_LIMITED_VERSION_HEX < 0x030A0000 + if (unlikely(PyArg_Parse(o, "s#", &result, length) < 0)) return NULL; + #else + result = PyUnicode_AsUTF8AndSize(o, length); + #endif + #if __PYX_DEFAULT_STRING_ENCODING_IS_ASCII + unicode_length = PyUnicode_GetLength(o); + if (unlikely(unicode_length < 0)) return NULL; + if (unlikely(unicode_length != *length)) { + PyUnicode_AsASCIIString(o); + return NULL; + } + #endif + return result; + } +#else +#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_UTF8 + if (PyUnicode_Check(o)) { + return __Pyx_PyUnicode_AsStringAndSize(o, length); + } else +#endif + if (PyByteArray_Check(o)) { +#if (CYTHON_ASSUME_SAFE_SIZE && CYTHON_ASSUME_SAFE_MACROS) || (CYTHON_COMPILING_IN_PYPY && (defined(PyByteArray_AS_STRING) && defined(PyByteArray_GET_SIZE))) + *length = PyByteArray_GET_SIZE(o); + return PyByteArray_AS_STRING(o); +#else + *length = PyByteArray_Size(o); + if (*length == -1) return NULL; + return PyByteArray_AsString(o); +#endif + } else + { + 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_LongWrongResultType(PyObject* result) { + __Pyx_TypeName result_type_name = __Pyx_PyType_GetFullyQualifiedName(Py_TYPE(result)); + 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; + } + PyErr_Format(PyExc_TypeError, + "__int__ returned non-int (type " __Pyx_FMT_TYPENAME ")", + result_type_name); + __Pyx_DECREF_TypeName(result_type_name); + Py_DECREF(result); + return NULL; +} +static CYTHON_INLINE PyObject* __Pyx_PyNumber_Long(PyObject* x) { +#if CYTHON_USE_TYPE_SLOTS + PyNumberMethods *m; +#endif + PyObject *res = NULL; + if (likely(PyLong_Check(x))) + return __Pyx_NewRef(x); +#if CYTHON_USE_TYPE_SLOTS + m = Py_TYPE(x)->tp_as_number; + if (likely(m && m->nb_int)) { + res = m->nb_int(x); + } +#else + if (!PyBytes_CheckExact(x) && !PyUnicode_CheckExact(x)) { + res = PyNumber_Long(x); + } +#endif + if (likely(res)) { + if (unlikely(!PyLong_CheckExact(res))) { + return __Pyx_PyNumber_LongWrongResultType(res); + } + } + 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 (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 = PyLong_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); + } else { + Py_ssize_t ival; + PyObject *x; + x = PyNumber_Index(o); + if (!x) return -1; + ival = PyLong_AsLong(x); + Py_DECREF(x); + return ival; + } +} +static CYTHON_INLINE PyObject *__Pyx_Owned_Py_None(int b) { + CYTHON_UNUSED_VAR(b); + return __Pyx_NewRef(Py_None); +} +static CYTHON_INLINE PyObject * __Pyx_PyBool_FromLong(long b) { + return b ? __Pyx_NewRef(Py_True) : __Pyx_NewRef(Py_False); +} +static CYTHON_INLINE PyObject * __Pyx_PyLong_FromSize_t(size_t ival) { + return PyLong_FromSize_t(ival); +} + + +/* MultiPhaseInitModuleState */ +#if CYTHON_PEP489_MULTI_PHASE_INIT && CYTHON_USE_MODULE_STATE +#ifndef CYTHON_MODULE_STATE_LOOKUP_THREAD_SAFE +#if (CYTHON_COMPILING_IN_LIMITED_API || PY_VERSION_HEX >= 0x030C0000) + #define CYTHON_MODULE_STATE_LOOKUP_THREAD_SAFE 1 +#else + #define CYTHON_MODULE_STATE_LOOKUP_THREAD_SAFE 0 +#endif +#endif +#if CYTHON_MODULE_STATE_LOOKUP_THREAD_SAFE && !CYTHON_ATOMICS +#error "Module state with PEP489 requires atomics. Currently that's one of\ + C11, C++11, gcc atomic intrinsics or MSVC atomic intrinsics" +#endif +#if !CYTHON_MODULE_STATE_LOOKUP_THREAD_SAFE +#define __Pyx_ModuleStateLookup_Lock() +#define __Pyx_ModuleStateLookup_Unlock() +#elif !CYTHON_COMPILING_IN_LIMITED_API && PY_VERSION_HEX >= 0x030d0000 +static PyMutex __Pyx_ModuleStateLookup_mutex = {0}; +#define __Pyx_ModuleStateLookup_Lock() PyMutex_Lock(&__Pyx_ModuleStateLookup_mutex) +#define __Pyx_ModuleStateLookup_Unlock() PyMutex_Unlock(&__Pyx_ModuleStateLookup_mutex) +#elif defined(__cplusplus) && __cplusplus >= 201103L +#include +static std::mutex __Pyx_ModuleStateLookup_mutex; +#define __Pyx_ModuleStateLookup_Lock() __Pyx_ModuleStateLookup_mutex.lock() +#define __Pyx_ModuleStateLookup_Unlock() __Pyx_ModuleStateLookup_mutex.unlock() +#elif defined(__STDC_VERSION__) && (__STDC_VERSION__ > 201112L) && !defined(__STDC_NO_THREADS__) +#include +static mtx_t __Pyx_ModuleStateLookup_mutex; +static once_flag __Pyx_ModuleStateLookup_mutex_once_flag = ONCE_FLAG_INIT; +static void __Pyx_ModuleStateLookup_initialize_mutex(void) { + mtx_init(&__Pyx_ModuleStateLookup_mutex, mtx_plain); +} +#define __Pyx_ModuleStateLookup_Lock()\ + call_once(&__Pyx_ModuleStateLookup_mutex_once_flag, __Pyx_ModuleStateLookup_initialize_mutex);\ + mtx_lock(&__Pyx_ModuleStateLookup_mutex) +#define __Pyx_ModuleStateLookup_Unlock() mtx_unlock(&__Pyx_ModuleStateLookup_mutex) +#elif defined(HAVE_PTHREAD_H) +#include +static pthread_mutex_t __Pyx_ModuleStateLookup_mutex = PTHREAD_MUTEX_INITIALIZER; +#define __Pyx_ModuleStateLookup_Lock() pthread_mutex_lock(&__Pyx_ModuleStateLookup_mutex) +#define __Pyx_ModuleStateLookup_Unlock() pthread_mutex_unlock(&__Pyx_ModuleStateLookup_mutex) +#elif defined(_WIN32) +#include // synchapi.h on its own doesn't work +static SRWLOCK __Pyx_ModuleStateLookup_mutex = SRWLOCK_INIT; +#define __Pyx_ModuleStateLookup_Lock() AcquireSRWLockExclusive(&__Pyx_ModuleStateLookup_mutex) +#define __Pyx_ModuleStateLookup_Unlock() ReleaseSRWLockExclusive(&__Pyx_ModuleStateLookup_mutex) +#else +#error "No suitable lock available for CYTHON_MODULE_STATE_LOOKUP_THREAD_SAFE.\ + Requires C standard >= C11, or C++ standard >= C++11,\ + or pthreads, or the Windows 32 API, or Python >= 3.13." +#endif +typedef struct { + int64_t id; + PyObject *module; +} __Pyx_InterpreterIdAndModule; +typedef struct { + char interpreter_id_as_index; + Py_ssize_t count; + Py_ssize_t allocated; + __Pyx_InterpreterIdAndModule table[1]; +} __Pyx_ModuleStateLookupData; +#define __PYX_MODULE_STATE_LOOKUP_SMALL_SIZE 32 +#if CYTHON_MODULE_STATE_LOOKUP_THREAD_SAFE +static __pyx_atomic_int_type __Pyx_ModuleStateLookup_read_counter = 0; +#endif +#if CYTHON_MODULE_STATE_LOOKUP_THREAD_SAFE +static __pyx_atomic_ptr_type __Pyx_ModuleStateLookup_data = 0; +#else +static __Pyx_ModuleStateLookupData* __Pyx_ModuleStateLookup_data = NULL; +#endif +static __Pyx_InterpreterIdAndModule* __Pyx_State_FindModuleStateLookupTableLowerBound( + __Pyx_InterpreterIdAndModule* table, + Py_ssize_t count, + int64_t interpreterId) { + __Pyx_InterpreterIdAndModule* begin = table; + __Pyx_InterpreterIdAndModule* end = begin + count; + if (begin->id == interpreterId) { + return begin; + } + while ((end - begin) > __PYX_MODULE_STATE_LOOKUP_SMALL_SIZE) { + __Pyx_InterpreterIdAndModule* halfway = begin + (end - begin)/2; + if (halfway->id == interpreterId) { + return halfway; + } + if (halfway->id < interpreterId) { + begin = halfway; + } else { + end = halfway; + } + } + for (; begin < end; ++begin) { + if (begin->id >= interpreterId) return begin; + } + return begin; +} +static PyObject *__Pyx_State_FindModule(CYTHON_UNUSED void* dummy) { + int64_t interpreter_id = PyInterpreterState_GetID(__Pyx_PyInterpreterState_Get()); + if (interpreter_id == -1) return NULL; +#if CYTHON_MODULE_STATE_LOOKUP_THREAD_SAFE + __Pyx_ModuleStateLookupData* data = (__Pyx_ModuleStateLookupData*)__pyx_atomic_pointer_load_relaxed(&__Pyx_ModuleStateLookup_data); + { + __pyx_atomic_incr_acq_rel(&__Pyx_ModuleStateLookup_read_counter); + if (likely(data)) { + __Pyx_ModuleStateLookupData* new_data = (__Pyx_ModuleStateLookupData*)__pyx_atomic_pointer_load_acquire(&__Pyx_ModuleStateLookup_data); + if (likely(data == new_data)) { + goto read_finished; + } + } + __pyx_atomic_decr_acq_rel(&__Pyx_ModuleStateLookup_read_counter); + __Pyx_ModuleStateLookup_Lock(); + __pyx_atomic_incr_relaxed(&__Pyx_ModuleStateLookup_read_counter); + data = (__Pyx_ModuleStateLookupData*)__pyx_atomic_pointer_load_relaxed(&__Pyx_ModuleStateLookup_data); + __Pyx_ModuleStateLookup_Unlock(); + } + read_finished:; +#else + __Pyx_ModuleStateLookupData* data = __Pyx_ModuleStateLookup_data; +#endif + __Pyx_InterpreterIdAndModule* found = NULL; + if (unlikely(!data)) goto end; + if (data->interpreter_id_as_index) { + if (interpreter_id < data->count) { + found = data->table+interpreter_id; + } + } else { + found = __Pyx_State_FindModuleStateLookupTableLowerBound( + data->table, data->count, interpreter_id); + } + end: + { + PyObject *result=NULL; + if (found && found->id == interpreter_id) { + result = found->module; + } +#if CYTHON_MODULE_STATE_LOOKUP_THREAD_SAFE + __pyx_atomic_decr_acq_rel(&__Pyx_ModuleStateLookup_read_counter); +#endif + return result; + } +} +#if CYTHON_MODULE_STATE_LOOKUP_THREAD_SAFE +static void __Pyx_ModuleStateLookup_wait_until_no_readers(void) { + while (__pyx_atomic_load(&__Pyx_ModuleStateLookup_read_counter) != 0); +} +#else +#define __Pyx_ModuleStateLookup_wait_until_no_readers() +#endif +static int __Pyx_State_AddModuleInterpIdAsIndex(__Pyx_ModuleStateLookupData **old_data, PyObject* module, int64_t interpreter_id) { + Py_ssize_t to_allocate = (*old_data)->allocated; + while (to_allocate <= interpreter_id) { + if (to_allocate == 0) to_allocate = 1; + else to_allocate *= 2; + } + __Pyx_ModuleStateLookupData *new_data = *old_data; + if (to_allocate != (*old_data)->allocated) { + new_data = (__Pyx_ModuleStateLookupData *)realloc( + *old_data, + sizeof(__Pyx_ModuleStateLookupData)+(to_allocate-1)*sizeof(__Pyx_InterpreterIdAndModule)); + if (!new_data) { + PyErr_NoMemory(); + return -1; + } + for (Py_ssize_t i = new_data->allocated; i < to_allocate; ++i) { + new_data->table[i].id = i; + new_data->table[i].module = NULL; + } + new_data->allocated = to_allocate; + } + new_data->table[interpreter_id].module = module; + if (new_data->count < interpreter_id+1) { + new_data->count = interpreter_id+1; + } + *old_data = new_data; + return 0; +} +static void __Pyx_State_ConvertFromInterpIdAsIndex(__Pyx_ModuleStateLookupData *data) { + __Pyx_InterpreterIdAndModule *read = data->table; + __Pyx_InterpreterIdAndModule *write = data->table; + __Pyx_InterpreterIdAndModule *end = read + data->count; + for (; readmodule) { + write->id = read->id; + write->module = read->module; + ++write; + } + } + data->count = write - data->table; + for (; writeid = 0; + write->module = NULL; + } + data->interpreter_id_as_index = 0; +} +static int __Pyx_State_AddModule(PyObject* module, CYTHON_UNUSED void* dummy) { + int64_t interpreter_id = PyInterpreterState_GetID(__Pyx_PyInterpreterState_Get()); + if (interpreter_id == -1) return -1; + int result = 0; + __Pyx_ModuleStateLookup_Lock(); +#if CYTHON_MODULE_STATE_LOOKUP_THREAD_SAFE + __Pyx_ModuleStateLookupData *old_data = (__Pyx_ModuleStateLookupData *) + __pyx_atomic_pointer_exchange(&__Pyx_ModuleStateLookup_data, 0); +#else + __Pyx_ModuleStateLookupData *old_data = __Pyx_ModuleStateLookup_data; +#endif + __Pyx_ModuleStateLookupData *new_data = old_data; + if (!new_data) { + new_data = (__Pyx_ModuleStateLookupData *)calloc(1, sizeof(__Pyx_ModuleStateLookupData)); + if (!new_data) { + result = -1; + PyErr_NoMemory(); + goto end; + } + new_data->allocated = 1; + new_data->interpreter_id_as_index = 1; + } + __Pyx_ModuleStateLookup_wait_until_no_readers(); + if (new_data->interpreter_id_as_index) { + if (interpreter_id < __PYX_MODULE_STATE_LOOKUP_SMALL_SIZE) { + result = __Pyx_State_AddModuleInterpIdAsIndex(&new_data, module, interpreter_id); + goto end; + } + __Pyx_State_ConvertFromInterpIdAsIndex(new_data); + } + { + Py_ssize_t insert_at = 0; + { + __Pyx_InterpreterIdAndModule* lower_bound = __Pyx_State_FindModuleStateLookupTableLowerBound( + new_data->table, new_data->count, interpreter_id); + assert(lower_bound); + insert_at = lower_bound - new_data->table; + if (unlikely(insert_at < new_data->count && lower_bound->id == interpreter_id)) { + lower_bound->module = module; + goto end; // already in table, nothing more to do + } + } + if (new_data->count+1 >= new_data->allocated) { + Py_ssize_t to_allocate = (new_data->count+1)*2; + new_data = + (__Pyx_ModuleStateLookupData*)realloc( + new_data, + sizeof(__Pyx_ModuleStateLookupData) + + (to_allocate-1)*sizeof(__Pyx_InterpreterIdAndModule)); + if (!new_data) { + result = -1; + new_data = old_data; + PyErr_NoMemory(); + goto end; + } + new_data->allocated = to_allocate; + } + ++new_data->count; + int64_t last_id = interpreter_id; + PyObject *last_module = module; + for (Py_ssize_t i=insert_at; icount; ++i) { + int64_t current_id = new_data->table[i].id; + new_data->table[i].id = last_id; + last_id = current_id; + PyObject *current_module = new_data->table[i].module; + new_data->table[i].module = last_module; + last_module = current_module; + } + } + end: +#if CYTHON_MODULE_STATE_LOOKUP_THREAD_SAFE + __pyx_atomic_pointer_exchange(&__Pyx_ModuleStateLookup_data, new_data); +#else + __Pyx_ModuleStateLookup_data = new_data; +#endif + __Pyx_ModuleStateLookup_Unlock(); + return result; +} +static int __Pyx_State_RemoveModule(CYTHON_UNUSED void* dummy) { + int64_t interpreter_id = PyInterpreterState_GetID(__Pyx_PyInterpreterState_Get()); + if (interpreter_id == -1) return -1; + __Pyx_ModuleStateLookup_Lock(); +#if CYTHON_MODULE_STATE_LOOKUP_THREAD_SAFE + __Pyx_ModuleStateLookupData *data = (__Pyx_ModuleStateLookupData *) + __pyx_atomic_pointer_exchange(&__Pyx_ModuleStateLookup_data, 0); +#else + __Pyx_ModuleStateLookupData *data = __Pyx_ModuleStateLookup_data; +#endif + if (data->interpreter_id_as_index) { + if (interpreter_id < data->count) { + data->table[interpreter_id].module = NULL; + } + goto done; + } + { + __Pyx_ModuleStateLookup_wait_until_no_readers(); + __Pyx_InterpreterIdAndModule* lower_bound = __Pyx_State_FindModuleStateLookupTableLowerBound( + data->table, data->count, interpreter_id); + if (!lower_bound) goto done; + if (lower_bound->id != interpreter_id) goto done; + __Pyx_InterpreterIdAndModule *end = data->table+data->count; + for (;lower_boundid = (lower_bound+1)->id; + lower_bound->module = (lower_bound+1)->module; + } + } + --data->count; + if (data->count == 0) { + free(data); + data = NULL; + } + done: +#if CYTHON_MODULE_STATE_LOOKUP_THREAD_SAFE + __pyx_atomic_pointer_exchange(&__Pyx_ModuleStateLookup_data, data); +#else + __Pyx_ModuleStateLookup_data = data; +#endif + __Pyx_ModuleStateLookup_Unlock(); + return 0; +} +#endif + +/* #### Code section: utility_code_pragmas_end ### */ +#ifdef _MSC_VER +#pragma warning( pop ) +#endif + + + +/* #### Code section: end ### */ +#endif /* Py_PYTHON_H */ diff --git a/www/src/scripts/builtins/execute-bash/execute_bash.py b/www/src/scripts/builtins/execute-bash/execute_bash.py new file mode 100644 index 0000000..81e37d5 --- /dev/null +++ b/www/src/scripts/builtins/execute-bash/execute_bash.py @@ -0,0 +1,11 @@ +def _execute_bash(*args): + from re import sub + from os import environ as hy_env + from subprocess import check_output + env = hy_env + env['PATH'] = hy_env['PATH'] + ':./scripts' + path = args[0] + with open(path, 'r') as fp: + _hy_anon_var_1 = fp.read() + print(sub('\\$\\[(.*?)\\]', lambda sequence: check_output(sequence.group(1), shell=True, executable='/bin/bash', env=env).decode().strip(), _hy_anon_var_1)) + return 0 diff --git a/www/src/scripts/execute-bash b/www/src/scripts/execute-bash deleted file mode 100755 index 446b3e7..0000000 --- a/www/src/scripts/execute-bash +++ /dev/null @@ -1,11 +0,0 @@ -#!/usr/bin/env hy -;; vim: filetype=hy -(import sys [argv]) -(import re [sub]) -(import os [environ :as hy-env]) -(import subprocess [check-output]) - -(setv env hy-env) -(setv (get env "PATH") (+ (get hy-env "PATH") ":./scripts")) - -(print (sub r"\$\[(.*?)\]" (fn [sequence] (. (check-output (.group sequence 1) :shell True :executable "/bin/bash" :env env) (decode) (strip))) (with [fp (open (get argv 1) "r")] (.read fp)))) diff --git a/www/src/scripts/include b/www/src/scripts/include index dc76d65..999b604 100755 --- a/www/src/scripts/include +++ b/www/src/scripts/include @@ -1,6 +1,6 @@ -#!/bin/sh - -output="$(execute-bash $1)" +#!/bin/bash +enable -f ./www/site/scripts/builtins/execute-bash/builtin execute_bash +output="$(execute_bash $1)" if [ -z "${2}" ]; then echo "${output}" | sed "${2}" else