Hugging Face's logo

dongbobo
/
MyAwesomeModel

Text Generation
Transformers
PyTorch
myawesomemodel
Model card Files
xet
 Community
MyAwesomeModel / evaluation /utils /__init__.c
dongbobo's picture
dongbobo
Initial upload of full bundle
73b70f9 verified
raw
history blame contribute delete
187 kB
/* Generated by Cython 3.1.2 */
/* BEGIN: Cython Metadata
{
 "distutils": {
 "name": "utils.__init__",
 "sources": [
 "utils/__init__.py"
 ]
 },
 "module_name": "utils.__init__"
}
END: Cython Metadata */
#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_2"
#define CYTHON_HEX_VERSION 0x030102F0
#define CYTHON_FUTURE_DIVISION 1
/* CModulePreamble */
#include <stddef.h>
#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<class T> 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 && !CYTHON_COMPILING_IN_CPYTHON_FREETHREADING
# 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 <stdint.h>
 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 <typename T>
 struct __PYX_IS_UNSIGNED_IMPL {static const bool value = T(0) < T(-1);};
 #define __PYX_IS_UNSIGNED(type) (__PYX_IS_UNSIGNED_IMPL<type>::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_AVOID_BORROWED_REFS || CYTHON_AVOID_THREAD_UNSAFE_BORROWED_REFS
 #if __PYX_LIMITED_VERSION_HEX >= 0x030d0000
 #define __Pyx_PyList_GetItemRef(o, i) PyList_GetItemRef(o, i)
 #elif CYTHON_COMPILING_IN_LIMITED_API || !CYTHON_ASSUME_SAFE_MACROS
 #define __Pyx_PyList_GetItemRef(o, i) (likely((i) >= 0) ? PySequence_GetItem(o, i) : (PyErr_SetString(PyExc_IndexError, "list index out of range"), (PyObject*)NULL))
 #else
 #define __Pyx_PyList_GetItemRef(o, i) PySequence_ITEM(o, i)
 #endif
#elif CYTHON_COMPILING_IN_LIMITED_API || !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) __Pyx_XNewRef(PyList_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 <math.h>
#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__utils
#define __PYX_HAVE_API__utils
/* Early includes */
#ifdef _OPENMP
#include <omp.h>
#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 <cstdlib>
 #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
#if __cplusplus > 201103L
#include <type_traits>
#endif
template <typename T>
static void __Pyx_pretend_to_initialize(T* ptr) {
#if __cplusplus > 201103L
 if ((std::is_trivially_default_constructible<T>::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[] = {
 "utils/__init__.py",
};
/* #### Code section: utility_code_proto_before_types ### */
/* 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
/* Atomics.proto */
#include <pythread.h>
#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 <stdatomic.h>
#elif CYTHON_ATOMICS && (defined(__cplusplus) && (\
 (__cplusplus >= 201103L) ||\
 (defined(_MSC_VER) && _MSC_VER >= 1700)))
 #include <atomic>
#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 <intrin.h>
 #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
/* #### Code section: numeric_typedefs ### */
/* #### Code section: complex_type_declarations ### */
/* #### Code section: type_declarations ### */
/*--- Type declarations ---*/
/* #### 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)
/* SetPackagePathFromImportLib.proto */
#if !CYTHON_PEP489_MULTI_PHASE_INIT
static int __Pyx_SetPackagePathFromImportLib(PyObject *module_name);
#else
#define __Pyx_SetPackagePathFromImportLib(a) 0
#endif
/* 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
/* 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);
/* 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);
/* 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
/* GCCDiagnostics.proto */
#if !defined(__INTEL_COMPILER) && defined(__GNUC__) && (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 6))
#define __Pyx_HAS_GCC_DIAGNOSTIC
#endif
/* 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);
/* 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
/* CIntToPy.proto */
static CYTHON_INLINE PyObject* __Pyx_PyLong_From_long(long value);
/* 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 "utils" */
/* #### Code section: typeinfo ### */
/* #### Code section: before_global_var ### */
#define __Pyx_MODULE_NAME "utils.__init__"
extern int __pyx_module_is_main_utils____init__;
int __pyx_module_is_main_utils____init__ = 0;
/* Implementation of "utils" */
/* #### Code section: global_var ### */
/* #### Code section: string_decls ### */
static const char __pyx_k_[] = "?";
static const char __pyx_k_main[] = "__main__";
static const char __pyx_k_name[] = "__name__";
static const char __pyx_k_test[] = "__test__";
static const char __pyx_k_module[] = "__module__";
static const char __pyx_k_qualname[] = "__qualname__";
static const char __pyx_k_utils___init[] = "utils.__init__";
static const char __pyx_k_cline_in_traceback[] = "cline_in_traceback";
/* #### Code section: decls ### */
/* #### 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_string_tab[8];
/* #### Code section: module_state_contents ### */
/* 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_cline_in_traceback __pyx_string_tab[1]
#define __pyx_n_u_main __pyx_string_tab[2]
#define __pyx_n_u_module __pyx_string_tab[3]
#define __pyx_n_u_name __pyx_string_tab[4]
#define __pyx_n_u_qualname __pyx_string_tab[5]
#define __pyx_n_u_test __pyx_string_tab[6]
#define __pyx_kp_u_utils___init __pyx_string_tab[7]
/* #### 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
 for (int i=0; i<8; ++i) { Py_CLEAR(clear_module_state->__pyx_string_tab[i]); }
 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
 for (int i=0; i<8; ++i) { __Pyx_VISIT_CONST(traverse_module_state->__pyx_string_tab[i]); }
 return 0;
}
#endif
/* #### Code section: module_code ### */
/* #### Code section: module_exttypes ### */
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);
 __Pyx_RefNannySetupContext("__Pyx_modinit_type_init_code", 0);
 /*--- Type init code ---*/
 __Pyx_RefNannyFinishContext();
 return 0;
}
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_utils(PyObject* module); /*proto*/
static PyModuleDef_Slot __pyx_moduledef_slots[] = {
 {Py_mod_create, (void*)__pyx_pymod_create},
 {Py_mod_exec, (void*)__pyx_pymod_exec_utils},
 #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,
 "utils",
 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_utils(void) CYTHON_SMALL_CODE; /*proto*/
#if !defined(CYTHON_NO_PYINIT_EXPORT) && (defined(_WIN32) || defined(WIN32) || defined(MS_WINDOWS))
__Pyx_PyMODINIT_FUNC PyInit___init__(void) { return PyInit_utils(); }
#endif
__Pyx_PyMODINIT_FUNC PyInit_utils(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_utils(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 'utils' 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 "utils" 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_utils", 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)
 /*--- 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 0 || defined(__Pyx_CyFunction_USED) || defined(__Pyx_FusedFunction_USED) || defined(__Pyx_Coroutine_USED) || defined(__Pyx_Generator_USED) || defined(__Pyx_AsyncGen_USED)
 if (__pyx_CommonTypesMetaclass_init(__pyx_m) < 0) __PYX_ERR(0, 1, __pyx_L1_error)
 #endif
 #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 ---*/
 if (__pyx_module_is_main_utils____init__) {
 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)
 }
 if (!CYTHON_PEP489_MULTI_PHASE_INIT) {
 if (unlikely((__Pyx_SetPackagePathFromImportLib(__pyx_mstate_global->__pyx_kp_u_utils___init) < 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, "utils")) {
 if (unlikely((PyDict_SetItemString(modules, "utils", __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);
 (void)__Pyx_modinit_type_init_code(__pyx_mstate);
 (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 ---*/
/* "utils/__init__.py":1
 * # Evaluation utilities package # <<<<<<<<<<<<<<
*/
 __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 utils", __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 utils");
 }
 __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 18 <= 65535
 const unsigned short n;
#elif 18 / 2 < INT_MAX
 const unsigned int n;
#elif 18 / 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_cline_in_traceback, sizeof(__pyx_k_cline_in_traceback), 0, 1, 1}, /* PyObject cname: __pyx_n_u_cline_in_traceback */
 {__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_qualname, sizeof(__pyx_k_qualname), 0, 1, 1}, /* PyObject cname: __pyx_n_u_qualname */
 {__pyx_k_test, sizeof(__pyx_k_test), 0, 1, 1}, /* PyObject cname: __pyx_n_u_test */
 {__pyx_k_utils___init, sizeof(__pyx_k_utils___init), 0, 1, 0}, /* PyObject cname: __pyx_kp_u_utils___init */
 {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);
 return 0;
}
/* #### Code section: cached_constants ### */
static int __Pyx_InitCachedConstants(__pyx_mstatetype *__pyx_mstate) {
 __Pyx_RefNannyDeclarations
 CYTHON_UNUSED_VAR(__pyx_mstate);
 __Pyx_RefNannySetupContext("__Pyx_InitCachedConstants", 0);
 __Pyx_RefNannyFinishContext();
 return 0;
}
/* #### Code section: init_constants ### */
static int __Pyx_InitConstants(__pyx_mstatetype *__pyx_mstate) {
 CYTHON_UNUSED_VAR(__pyx_mstate);
 if (__Pyx_InitStrings(__pyx_string_tab, __pyx_mstate->__pyx_string_tab, __pyx_string_tab_encodings) < 0) __PYX_ERR(0, 1, __pyx_L1_error);
 return 0;
 __pyx_L1_error:;
 return -1;
}
/* #### Code section: init_codeobjects ### */
static int __Pyx_CreateCodeObjects(__pyx_mstatetype *__pyx_mstate) {
 CYTHON_UNUSED_VAR(__pyx_mstate);
 return 0;
}
/* #### 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)
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
/* SetPackagePathFromImportLib */
#if !CYTHON_PEP489_MULTI_PHASE_INIT
static int __Pyx_SetPackagePathFromImportLib(PyObject *module_name) {
 PyObject *importlib, *osmod, *ossep, *parts, *package_path;
 PyObject *file_path = NULL;
 PyObject *item;
 int result;
 PyObject *spec;
 importlib = PyImport_ImportModule("importlib.util");
 if (unlikely(!importlib))
 goto bad;
 spec = PyObject_CallMethod(importlib, "find_spec", "(O)", module_name);
 Py_DECREF(importlib);
 if (unlikely(!spec))
 goto bad;
 file_path = PyObject_GetAttrString(spec, "origin");
 Py_DECREF(spec);
 if (unlikely(!file_path))
 goto bad;
 if (unlikely(PyObject_SetAttrString(__pyx_m, "__file__", file_path) < 0))
 goto bad;
 osmod = PyImport_ImportModule("os");
 if (unlikely(!osmod))
 goto bad;
 ossep = PyObject_GetAttrString(osmod, "sep");
 Py_DECREF(osmod);
 if (unlikely(!ossep))
 goto bad;
 parts = PyObject_CallMethod(file_path, "rsplit", "(Oi)", ossep, 1);
 Py_DECREF(file_path); file_path = NULL;
 Py_DECREF(ossep);
 if (unlikely(!parts))
 goto bad;
#if CYTHON_ASSUME_SAFE_MACROS
 package_path = Py_BuildValue("[O]", PyList_GET_ITEM(parts, 0));
#else
 item = PyList_GetItem(parts, 0);
 if (unlikely(!item))
 goto bad;
 package_path = Py_BuildValue("[O]", item);
#endif
 Py_DECREF(parts);
 if (unlikely(!package_path))
 goto bad;
 goto set_path;
bad:
 PyErr_WriteUnraisable(module_name);
 Py_XDECREF(file_path);
 PyErr_Clear();
 package_path = PyList_New(0);
 if (unlikely(!package_path))
 return -1;
set_path:
 result = PyObject_SetAttrString(__pyx_m, "__path__", package_path);
 Py_DECREF(package_path);
 return result;
}
#endif
/* PyDictVersioning */
#if CYTHON_USE_DICT_VERSIONS && CYTHON_USE_TYPE_SLOTS
static CYTHON_INLINE PY_UINT64_T __Pyx_get_tp_dict_version(PyObject *obj) {
 PyObject *dict = Py_TYPE(obj)->tp_dict;
 return likely(dict) ? __PYX_GET_DICT_VERSION(dict) : 0;
}
static CYTHON_INLINE PY_UINT64_T __Pyx_get_object_dict_version(PyObject *obj) {
 PyObject **dictptr = NULL;
 Py_ssize_t offset = Py_TYPE(obj)->tp_dictoffset;
 if (offset) {
#if CYTHON_COMPILING_IN_CPYTHON
 dictptr = (likely(offset > 0)) ? (PyObject **) ((char *)obj + offset) : _PyObject_GetDictPtr(obj);
#else
 dictptr = _PyObject_GetDictPtr(obj);
#endif
 }
 return (dictptr && *dictptr) ? __PYX_GET_DICT_VERSION(*dictptr) : 0;
}
static CYTHON_INLINE int __Pyx_object_dict_version_matches(PyObject* obj, PY_UINT64_T tp_dict_version, PY_UINT64_T obj_dict_version) {
 PyObject *dict = Py_TYPE(obj)->tp_dict;
 if (unlikely(!dict) || unlikely(tp_dict_version != __PYX_GET_DICT_VERSION(dict)))
 return 0;
 return obj_dict_version == __Pyx_get_object_dict_version(obj);
}
#endif
/* 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<n; i++) {
 if (exc_type == PyTuple_GET_ITEM(tuple, i)) return 1;
 }
 for (i=0; i<n; i++) {
 if (__Pyx_PyErr_GivenExceptionMatches(exc_type, PyTuple_GET_ITEM(tuple, i))) return 1;
 }
 return 0;
}
static CYTHON_INLINE int __Pyx_PyErr_ExceptionMatchesInState(PyThreadState* tstate, PyObject* err) {
 int result;
 PyObject *exc_type;
#if PY_VERSION_HEX >= 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
}
/* 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
/* 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_);
 }
 goto done;
}
#endif
/* PyFunctionFastCall */
#if CYTHON_FAST_PYCALL && !CYTHON_VECTORCALL
static PyObject* __Pyx_PyFunction_FastCallNoKw(PyCodeObject *co, PyObject *const *args, Py_ssize_t na,
 PyObject *globals) {
 PyFrameObject *f;
 PyThreadState *tstate = __Pyx_PyThreadState_Current;
 PyObject **fastlocals;
 Py_ssize_t i;
 PyObject *result;
 assert(globals != NULL);
 /* XXX Perhaps we should create a specialized
 PyFrame_New() that doesn't take locals, but does
 take builtins without sanity checking them.
 */
 assert(tstate != NULL);
 f = PyFrame_New(tstate, co, globals, NULL);
 if (f == NULL) {
 return NULL;
 }
 fastlocals = __Pyx_PyFrame_GetLocalsplus(f);
 for (i = 0; i < na; i++) {
 Py_INCREF(*args);
 fastlocals[i] = *args++;
 }
 result = PyEval_EvalFrameEx(f,0);
 ++tstate->recursion_depth;
 Py_DECREF(f);
 --tstate->recursion_depth;
 return result;
}
static PyObject *__Pyx_PyFunction_FastCallDict(PyObject *func, PyObject *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
}
/* 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
/* 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
 }
}
/* 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<n; i++) {
 if (exc_type == PyTuple_GET_ITEM(tuple, i)) return 1;
 }
 for (i=0; i<n; i++) {
 PyObject *t = PyTuple_GET_ITEM(tuple, i);
 if (likely(PyExceptionClass_Check(t))) {
 if (__Pyx_inner_PyErr_GivenExceptionMatches2(exc_type, NULL, t)) return 1;
 } else {
 }
 }
 return 0;
}
static CYTHON_INLINE int __Pyx_PyErr_GivenExceptionMatches(PyObject *err, PyObject* exc_type) {
 if (likely(err == exc_type)) return 1;
 if (likely(PyExceptionClass_Check(err))) {
 if (likely(PyExceptionClass_Check(exc_type))) {
 return __Pyx_inner_PyErr_GivenExceptionMatches2(err, NULL, exc_type);
 } else if (likely(PyTuple_Check(exc_type))) {
 return __Pyx_PyErr_GivenExceptionMatchesTuple(err, exc_type);
 } else {
 }
 }
 return PyErr_GivenExceptionMatches(err, exc_type);
}
static CYTHON_INLINE int __Pyx_PyErr_GivenExceptionMatches2(PyObject *err, PyObject *exc_type1, PyObject *exc_type2) {
 assert(PyExceptionClass_Check(exc_type1));
 assert(PyExceptionClass_Check(exc_type2));
 if (likely(err == exc_type1 || err == exc_type2)) return 1;
 if (likely(PyExceptionClass_Check(err))) {
 return __Pyx_inner_PyErr_GivenExceptionMatches2(err, exc_type1, exc_type2);
 }
 return (PyErr_GivenExceptionMatches(err, exc_type1) || PyErr_GivenExceptionMatches(err, exc_type2));
}
#endif
/* GetRuntimeVersion */
static unsigned long __Pyx_get_runtime_version(void) {
#if __PYX_LIMITED_VERSION_HEX >= 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);
 }
}
/* 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 <string.h>
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 <mutex>
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 <threads.h>
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 <pthread.h>
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 <Windows.h> // 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 (; read<end; ++read) {
 if (read->module) {
 write->id = read->id;
 write->module = read->module;
 ++write;
 }
 }
 data->count = write - data->table;
 for (; write<end; ++write) {
 write->id = 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; i<new_data->count; ++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_bound<end-1; ++lower_bound) {
 lower_bound->id = (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 */