/* Generated by Cython 0.29.21 */

#define PY_SSIZE_T_CLEAN

#include "Python.h"

#ifndef Py_PYTHON_H

#error Python headers needed to compile C extensions, please install development version of Python.

#elif PY_VERSION_HEX < 0x02060000 || (0x03000000 <= PY_VERSION_HEX && PY_VERSION_HEX < 0x03030000)

#error Cython requires Python 2.6+ or Python 3.3+.

#else

#define CYTHON_ABI "0_29_21"

#define CYTHON_HEX_VERSION 0x001D15F0

#define CYTHON_FUTURE_DIVISION 0

#include <stddef.h>

#ifndef offsetof

#define offsetof(type, member) ( (size_t) & ((type*)0) -> member )

#endif

#if !defined(WIN32) && !defined(MS_WINDOWS)

#ifndef __stdcall

#define __stdcall

#endif

#ifndef __cdecl

#define __cdecl

#endif

#ifndef __fastcall

#define __fastcall

#endif

#endif

#ifndef DL_IMPORT

#define DL_IMPORT(t) t

#endif

#ifndef DL_EXPORT

#define DL_EXPORT(t) t

#endif

#define __PYX_COMMA ,

#ifndef HAVE_LONG_LONG

#if PY_VERSION_HEX >= 0x02070000

#define HAVE_LONG_LONG

#endif

#endif

#ifndef PY_LONG_LONG

#define PY_LONG_LONG LONG_LONG

#endif

#ifndef Py_HUGE_VAL

#define Py_HUGE_VAL HUGE_VAL

#endif

#ifdef PYPY_VERSION

#define CYTHON_COMPILING_IN_PYPY 1

#define CYTHON_COMPILING_IN_PYSTON 0

#define CYTHON_COMPILING_IN_CPYTHON 0

#undef CYTHON_USE_TYPE_SLOTS

#define CYTHON_USE_TYPE_SLOTS 0

#undef CYTHON_USE_PYTYPE_LOOKUP

#define CYTHON_USE_PYTYPE_LOOKUP 0

#if PY_VERSION_HEX < 0x03050000

#undef CYTHON_USE_ASYNC_SLOTS

#define CYTHON_USE_ASYNC_SLOTS 0

#elif !defined(CYTHON_USE_ASYNC_SLOTS)

#define CYTHON_USE_ASYNC_SLOTS 1

#endif

#undef CYTHON_USE_PYLIST_INTERNALS

#define CYTHON_USE_PYLIST_INTERNALS 0

#undef CYTHON_USE_UNICODE_INTERNALS

#define CYTHON_USE_UNICODE_INTERNALS 0

#undef CYTHON_USE_UNICODE_WRITER

#define CYTHON_USE_UNICODE_WRITER 0

#undef CYTHON_USE_PYLONG_INTERNALS

#define CYTHON_USE_PYLONG_INTERNALS 0

#undef CYTHON_AVOID_BORROWED_REFS

#define CYTHON_AVOID_BORROWED_REFS 1

#undef CYTHON_ASSUME_SAFE_MACROS

#define CYTHON_ASSUME_SAFE_MACROS 0

#undef CYTHON_UNPACK_METHODS

#define CYTHON_UNPACK_METHODS 0

#undef CYTHON_FAST_THREAD_STATE

#define CYTHON_FAST_THREAD_STATE 0

#undef CYTHON_FAST_PYCALL

#define CYTHON_FAST_PYCALL 0

#undef CYTHON_PEP489_MULTI_PHASE_INIT

#define CYTHON_PEP489_MULTI_PHASE_INIT 0

#undef CYTHON_USE_TP_FINALIZE

#define CYTHON_USE_TP_FINALIZE 0

#undef CYTHON_USE_DICT_VERSIONS

#define CYTHON_USE_DICT_VERSIONS 0

#undef CYTHON_USE_EXC_INFO_STACK

#define CYTHON_USE_EXC_INFO_STACK 0

#elif defined(PYSTON_VERSION)

#define CYTHON_COMPILING_IN_PYPY 0

#define CYTHON_COMPILING_IN_PYSTON 1

#define CYTHON_COMPILING_IN_CPYTHON 0

#ifndef CYTHON_USE_TYPE_SLOTS

#define CYTHON_USE_TYPE_SLOTS 1

#endif

#undef CYTHON_USE_PYTYPE_LOOKUP

#define CYTHON_USE_PYTYPE_LOOKUP 0

#undef CYTHON_USE_ASYNC_SLOTS

#define CYTHON_USE_ASYNC_SLOTS 0

#undef CYTHON_USE_PYLIST_INTERNALS

#define CYTHON_USE_PYLIST_INTERNALS 0

#ifndef CYTHON_USE_UNICODE_INTERNALS

#define CYTHON_USE_UNICODE_INTERNALS 1

#endif

#undef CYTHON_USE_UNICODE_WRITER

#define CYTHON_USE_UNICODE_WRITER 0

#undef CYTHON_USE_PYLONG_INTERNALS

#define CYTHON_USE_PYLONG_INTERNALS 0

#ifndef CYTHON_AVOID_BORROWED_REFS

#define CYTHON_AVOID_BORROWED_REFS 0

#endif

#ifndef CYTHON_ASSUME_SAFE_MACROS

#define CYTHON_ASSUME_SAFE_MACROS 1

#endif

#ifndef CYTHON_UNPACK_METHODS

#define CYTHON_UNPACK_METHODS 1

#endif

#undef CYTHON_FAST_THREAD_STATE

#define CYTHON_FAST_THREAD_STATE 0

#undef CYTHON_FAST_PYCALL

#define CYTHON_FAST_PYCALL 0

#undef CYTHON_PEP489_MULTI_PHASE_INIT

#define CYTHON_PEP489_MULTI_PHASE_INIT 0

#undef CYTHON_USE_TP_FINALIZE

#define CYTHON_USE_TP_FINALIZE 0

#undef CYTHON_USE_DICT_VERSIONS

#define CYTHON_USE_DICT_VERSIONS 0

#undef CYTHON_USE_EXC_INFO_STACK

#define CYTHON_USE_EXC_INFO_STACK 0

#else

#define CYTHON_COMPILING_IN_PYPY 0

#define CYTHON_COMPILING_IN_PYSTON 0

#define CYTHON_COMPILING_IN_CPYTHON 1

#ifndef CYTHON_USE_TYPE_SLOTS

#define CYTHON_USE_TYPE_SLOTS 1

#endif

#if PY_VERSION_HEX < 0x02070000

#undef CYTHON_USE_PYTYPE_LOOKUP

#define CYTHON_USE_PYTYPE_LOOKUP 0

#elif !defined(CYTHON_USE_PYTYPE_LOOKUP)

#define CYTHON_USE_PYTYPE_LOOKUP 1

#endif

#if PY_MAJOR_VERSION < 3

#undef CYTHON_USE_ASYNC_SLOTS

#define CYTHON_USE_ASYNC_SLOTS 0

#elif !defined(CYTHON_USE_ASYNC_SLOTS)

#define CYTHON_USE_ASYNC_SLOTS 1

#endif

#if PY_VERSION_HEX < 0x02070000

#undef CYTHON_USE_PYLONG_INTERNALS

#define CYTHON_USE_PYLONG_INTERNALS 0

#elif !defined(CYTHON_USE_PYLONG_INTERNALS)

#define CYTHON_USE_PYLONG_INTERNALS 1

#endif

#ifndef CYTHON_USE_PYLIST_INTERNALS

#define CYTHON_USE_PYLIST_INTERNALS 1

#endif

#ifndef CYTHON_USE_UNICODE_INTERNALS

#define CYTHON_USE_UNICODE_INTERNALS 1

#endif

#if PY_VERSION_HEX < 0x030300F0

#undef CYTHON_USE_UNICODE_WRITER

#define CYTHON_USE_UNICODE_WRITER 0

#elif !defined(CYTHON_USE_UNICODE_WRITER)

#define CYTHON_USE_UNICODE_WRITER 1

#endif

#ifndef CYTHON_AVOID_BORROWED_REFS

#define CYTHON_AVOID_BORROWED_REFS 0

#endif

#ifndef CYTHON_ASSUME_SAFE_MACROS

#define CYTHON_ASSUME_SAFE_MACROS 1

#endif

#ifndef CYTHON_UNPACK_METHODS

#define CYTHON_UNPACK_METHODS 1

#endif

#ifndef CYTHON_FAST_THREAD_STATE

#define CYTHON_FAST_THREAD_STATE 1

#endif

#ifndef CYTHON_FAST_PYCALL

#define CYTHON_FAST_PYCALL 1

#endif

#ifndef CYTHON_PEP489_MULTI_PHASE_INIT

#define CYTHON_PEP489_MULTI_PHASE_INIT (PY_VERSION_HEX >= 0x03050000)

#endif

#ifndef CYTHON_USE_TP_FINALIZE

#define CYTHON_USE_TP_FINALIZE (PY_VERSION_HEX >= 0x030400a1)

#endif

#ifndef CYTHON_USE_DICT_VERSIONS

#define CYTHON_USE_DICT_VERSIONS (PY_VERSION_HEX >= 0x030600B1)

#endif

#ifndef CYTHON_USE_EXC_INFO_STACK

#define CYTHON_USE_EXC_INFO_STACK (PY_VERSION_HEX >= 0x030700A3)

#endif

#endif

#if !defined(CYTHON_FAST_PYCCALL)

#define CYTHON_FAST_PYCCALL (CYTHON_FAST_PYCALL && PY_VERSION_HEX >= 0x030600B1)

#endif

#if CYTHON_USE_PYLONG_INTERNALS

#include "longintrepr.h"

#undef SHIFT

#undef BASE

#undef MASK

#ifdef SIZEOF_VOID_P

enum { __pyx_check_sizeof_voidp = 1 / (int)(SIZEOF_VOID_P == sizeof(void*)) };

#endif

#endif

#ifndef __has_attribute

#define __has_attribute(x) 0

#endif

#ifndef __has_cpp_attribute

#define __has_cpp_attribute(x) 0

#endif

#ifndef CYTHON_RESTRICT

#if defined(__GNUC__)

#define CYTHON_RESTRICT __restrict__

#elif defined(_MSC_VER) && _MSC_VER >= 1400

#define CYTHON_RESTRICT __restrict

#elif defined (__STDC_VERSION__) && __STDC_VERSION__ >= 199901L

#define CYTHON_RESTRICT restrict

#else

#define CYTHON_RESTRICT

#endif

#endif

#ifndef CYTHON_UNUSED

# if defined(__GNUC__)

# if !(defined(__cplusplus)) || (__GNUC__ > 3 || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4))

# define CYTHON_UNUSED __attribute__ ((__unused__))

# else

# define CYTHON_UNUSED

# endif

# elif defined(__ICC) || (defined(__INTEL_COMPILER) && !defined(_MSC_VER))

# define CYTHON_UNUSED __attribute__ ((__unused__))

# else

# define CYTHON_UNUSED

# endif

#endif

#ifndef CYTHON_MAYBE_UNUSED_VAR

# if defined(__cplusplus)

template<class T> void CYTHON_MAYBE_UNUSED_VAR( const T& ) { }

# else

# define CYTHON_MAYBE_UNUSED_VAR(x) (void)(x)

# endif

#endif

#ifndef CYTHON_NCP_UNUSED

# if CYTHON_COMPILING_IN_CPYTHON

# define CYTHON_NCP_UNUSED

# else

# define CYTHON_NCP_UNUSED CYTHON_UNUSED

# endif

#endif

#define __Pyx_void_to_None(void_result) ((void)(void_result), Py_INCREF(Py_None), Py_None)

#ifdef _MSC_VER

#ifndef _MSC_STDINT_H_

#if _MSC_VER < 1300

typedef unsigned char uint8_t;

typedef unsigned int uint32_t;

#else

typedef unsigned __int8 uint8_t;

typedef unsigned __int32 uint32_t;

#endif

#endif

#else

#include <stdint.h>

#endif

#ifndef CYTHON_FALLTHROUGH

#if defined(__cplusplus) && __cplusplus >= 201103L

#if __has_cpp_attribute(fallthrough)

#define CYTHON_FALLTHROUGH [[fallthrough]]

#elif __has_cpp_attribute(clang::fallthrough)

#define CYTHON_FALLTHROUGH [[clang::fallthrough]]

#elif __has_cpp_attribute(gnu::fallthrough)

#define CYTHON_FALLTHROUGH [[gnu::fallthrough]]

#endif

#endif

#ifndef CYTHON_FALLTHROUGH

#if __has_attribute(fallthrough)

#define CYTHON_FALLTHROUGH __attribute__((fallthrough))

#else

#define CYTHON_FALLTHROUGH

#endif

#endif

#if defined(__clang__ ) && defined(__apple_build_version__)

#if __apple_build_version__ < 7000000

#undef CYTHON_FALLTHROUGH

#define CYTHON_FALLTHROUGH

#endif

#endif

#endif

#ifndef CYTHON_INLINE

#if defined(__clang__)

#define CYTHON_INLINE __inline__ __attribute__ ((__unused__))

#elif defined(__GNUC__)

#define CYTHON_INLINE __inline__

#elif defined(_MSC_VER)

#define CYTHON_INLINE __inline

#elif defined (__STDC_VERSION__) && __STDC_VERSION__ >= 199901L

#define CYTHON_INLINE inline

#else

#define CYTHON_INLINE

#endif

#endif

#if CYTHON_COMPILING_IN_PYPY && PY_VERSION_HEX < 0x02070600 && !defined(Py_OptimizeFlag)

#define Py_OptimizeFlag 0

#endif

#define __PYX_BUILD_PY_SSIZE_T "n"

#define CYTHON_FORMAT_SSIZE_T "z"

#if PY_MAJOR_VERSION < 3

#define __Pyx_BUILTIN_MODULE_NAME "__builtin__"

#define __Pyx_PyCode_New(a, k, l, s, f, code, c, n, v, fv, cell, fn, name, fline, lnos)\

PyCode_New(a+k, l, s, f, code, c, n, v, fv, cell, fn, name, fline, lnos)

#define __Pyx_DefaultClassType PyClass_Type

#else

#define __Pyx_BUILTIN_MODULE_NAME "builtins"

#if PY_VERSION_HEX >= 0x030800A4 && PY_VERSION_HEX < 0x030800B2

#define __Pyx_PyCode_New(a, k, l, s, f, code, c, n, v, fv, cell, fn, name, fline, lnos)\

PyCode_New(a, 0, k, l, s, f, code, c, n, v, fv, cell, fn, name, fline, lnos)

#else

#define __Pyx_PyCode_New(a, k, l, s, f, code, c, n, v, fv, cell, fn, name, fline, lnos)\

PyCode_New(a, k, l, s, f, code, c, n, v, fv, cell, fn, name, fline, lnos)

#endif

#define __Pyx_DefaultClassType PyType_Type

#endif

#ifndef Py_TPFLAGS_CHECKTYPES

#define Py_TPFLAGS_CHECKTYPES 0

#endif

#ifndef Py_TPFLAGS_HAVE_INDEX

#define Py_TPFLAGS_HAVE_INDEX 0

#endif

#ifndef Py_TPFLAGS_HAVE_NEWBUFFER

#define Py_TPFLAGS_HAVE_NEWBUFFER 0

#endif

#ifndef Py_TPFLAGS_HAVE_FINALIZE

#define Py_TPFLAGS_HAVE_FINALIZE 0

#endif

#ifndef METH_STACKLESS

#define METH_STACKLESS 0

#endif

#if PY_VERSION_HEX <= 0x030700A3 || !defined(METH_FASTCALL)

#ifndef METH_FASTCALL

#define METH_FASTCALL 0x80

#endif

typedef PyObject *(*__Pyx_PyCFunctionFast) (PyObject *self, PyObject *const *args, Py_ssize_t nargs);

typedef PyObject *(*__Pyx_PyCFunctionFastWithKeywords) (PyObject *self, PyObject *const *args,

Py_ssize_t nargs, PyObject *kwnames);

#else

#define __Pyx_PyCFunctionFast _PyCFunctionFast

#define __Pyx_PyCFunctionFastWithKeywords _PyCFunctionFastWithKeywords

#endif

#if CYTHON_FAST_PYCCALL

#define __Pyx_PyFastCFunction_Check(func)\

((PyCFunction_Check(func) && (METH_FASTCALL == (PyCFunction_GET_FLAGS(func) & ~(METH_CLASS | METH_STATIC | METH_COEXIST | METH_KEYWORDS | METH_STACKLESS)))))

#else

#define __Pyx_PyFastCFunction_Check(func) 0

#endif

#if CYTHON_COMPILING_IN_PYPY && !defined(PyObject_Malloc)

#define PyObject_Malloc(s) PyMem_Malloc(s)

#define PyObject_Free(p) PyMem_Free(p)

#define PyObject_Realloc(p) PyMem_Realloc(p)

#endif

#if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX < 0x030400A1

#define PyMem_RawMalloc(n) PyMem_Malloc(n)

#define PyMem_RawRealloc(p, n) PyMem_Realloc(p, n)

#define PyMem_RawFree(p) PyMem_Free(p)

#endif

#if CYTHON_COMPILING_IN_PYSTON

#define __Pyx_PyCode_HasFreeVars(co) PyCode_HasFreeVars(co)

#define __Pyx_PyFrame_SetLineNumber(frame, lineno) PyFrame_SetLineNumber(frame, lineno)

#else

#define __Pyx_PyCode_HasFreeVars(co) (PyCode_GetNumFree(co) > 0)

#define __Pyx_PyFrame_SetLineNumber(frame, lineno) (frame)->f_lineno = (lineno)

#endif

#if !CYTHON_FAST_THREAD_STATE || PY_VERSION_HEX < 0x02070000

#define __Pyx_PyThreadState_Current PyThreadState_GET()

#elif PY_VERSION_HEX >= 0x03060000

#define __Pyx_PyThreadState_Current _PyThreadState_UncheckedGet()

#elif PY_VERSION_HEX >= 0x03000000

#define __Pyx_PyThreadState_Current PyThreadState_GET()

#else

#define __Pyx_PyThreadState_Current _PyThreadState_Current

#endif

#if PY_VERSION_HEX < 0x030700A2 && !defined(PyThread_tss_create) && !defined(Py_tss_NEEDS_INIT)

#include "pythread.h"

#define Py_tss_NEEDS_INIT 0

typedef int Py_tss_t;

static CYTHON_INLINE int PyThread_tss_create(Py_tss_t *key) {

*key = PyThread_create_key();

return 0;

}

static CYTHON_INLINE Py_tss_t * PyThread_tss_alloc(void) {

Py_tss_t *key = (Py_tss_t *)PyObject_Malloc(sizeof(Py_tss_t));

*key = Py_tss_NEEDS_INIT;

return key;

}

static CYTHON_INLINE void PyThread_tss_free(Py_tss_t *key) {

PyObject_Free(key);

}

static CYTHON_INLINE int PyThread_tss_is_created(Py_tss_t *key) {

return *key != Py_tss_NEEDS_INIT;

}

static CYTHON_INLINE void PyThread_tss_delete(Py_tss_t *key) {

PyThread_delete_key(*key);

*key = Py_tss_NEEDS_INIT;

}

static CYTHON_INLINE int PyThread_tss_set(Py_tss_t *key, void *value) {

return PyThread_set_key_value(*key, value);

}

static CYTHON_INLINE void * PyThread_tss_get(Py_tss_t *key) {

return PyThread_get_key_value(*key);

}

#endif

#if CYTHON_COMPILING_IN_CPYTHON || defined(_PyDict_NewPresized)

#define __Pyx_PyDict_NewPresized(n) ((n <= 8) ? PyDict_New() : _PyDict_NewPresized(n))

#else

#define __Pyx_PyDict_NewPresized(n) PyDict_New()

#endif

#if PY_MAJOR_VERSION >= 3 || CYTHON_FUTURE_DIVISION

#define __Pyx_PyNumber_Divide(x,y) PyNumber_TrueDivide(x,y)

#define __Pyx_PyNumber_InPlaceDivide(x,y) PyNumber_InPlaceTrueDivide(x,y)

#else

#define __Pyx_PyNumber_Divide(x,y) PyNumber_Divide(x,y)

#define __Pyx_PyNumber_InPlaceDivide(x,y) PyNumber_InPlaceDivide(x,y)

#endif

#if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030500A1 && CYTHON_USE_UNICODE_INTERNALS

#define __Pyx_PyDict_GetItemStr(dict, name) _PyDict_GetItem_KnownHash(dict, name, ((PyASCIIObject *) name)->hash)

#else

#define __Pyx_PyDict_GetItemStr(dict, name) PyDict_GetItem(dict, name)

#endif

#if PY_VERSION_HEX > 0x03030000 && defined(PyUnicode_KIND)

#define CYTHON_PEP393_ENABLED 1

#define __Pyx_PyUnicode_READY(op) (likely(PyUnicode_IS_READY(op)) ?\

0 : _PyUnicode_Ready((PyObject *)(op)))

#define __Pyx_PyUnicode_GET_LENGTH(u) PyUnicode_GET_LENGTH(u)

#define __Pyx_PyUnicode_READ_CHAR(u, i) PyUnicode_READ_CHAR(u, i)

#define __Pyx_PyUnicode_MAX_CHAR_VALUE(u) PyUnicode_MAX_CHAR_VALUE(u)

#define __Pyx_PyUnicode_KIND(u) PyUnicode_KIND(u)

#define __Pyx_PyUnicode_DATA(u) PyUnicode_DATA(u)

#define __Pyx_PyUnicode_READ(k, d, i) PyUnicode_READ(k, d, i)

#define __Pyx_PyUnicode_WRITE(k, d, i, ch) PyUnicode_WRITE(k, d, i, ch)

#if defined(PyUnicode_IS_READY) && defined(PyUnicode_GET_SIZE)

#define __Pyx_PyUnicode_IS_TRUE(u) (0 != (likely(PyUnicode_IS_READY(u)) ? PyUnicode_GET_LENGTH(u) : PyUnicode_GET_SIZE(u)))

#else

#define __Pyx_PyUnicode_IS_TRUE(u) (0 != PyUnicode_GET_LENGTH(u))

#endif

#else

#define CYTHON_PEP393_ENABLED 0

#define PyUnicode_1BYTE_KIND 1

#define PyUnicode_2BYTE_KIND 2

#define PyUnicode_4BYTE_KIND 4

#define __Pyx_PyUnicode_READY(op) (0)

#define __Pyx_PyUnicode_GET_LENGTH(u) PyUnicode_GET_SIZE(u)

#define __Pyx_PyUnicode_READ_CHAR(u, i) ((Py_UCS4)(PyUnicode_AS_UNICODE(u)[i]))

#define __Pyx_PyUnicode_MAX_CHAR_VALUE(u) ((sizeof(Py_UNICODE) == 2) ? 65535 : 1114111)

#define __Pyx_PyUnicode_KIND(u) (sizeof(Py_UNICODE))

#define __Pyx_PyUnicode_DATA(u) ((void*)PyUnicode_AS_UNICODE(u))

#define __Pyx_PyUnicode_READ(k, d, i) ((void)(k), (Py_UCS4)(((Py_UNICODE*)d)[i]))

#define __Pyx_PyUnicode_WRITE(k, d, i, ch) (((void)(k)), ((Py_UNICODE*)d)[i] = ch)

#define __Pyx_PyUnicode_IS_TRUE(u) (0 != PyUnicode_GET_SIZE(u))

#endif

#if CYTHON_COMPILING_IN_PYPY

#define __Pyx_PyUnicode_Concat(a, b) PyNumber_Add(a, b)

#define __Pyx_PyUnicode_ConcatSafe(a, b) PyNumber_Add(a, b)

#else

#define __Pyx_PyUnicode_Concat(a, b) PyUnicode_Concat(a, b)

#define __Pyx_PyUnicode_ConcatSafe(a, b) ((unlikely((a) == Py_None) || unlikely((b) == Py_None)) ?\

PyNumber_Add(a, b) : __Pyx_PyUnicode_Concat(a, b))

#endif

#if CYTHON_COMPILING_IN_PYPY && !defined(PyUnicode_Contains)

#define PyUnicode_Contains(u, s) PySequence_Contains(u, s)

#endif

#if CYTHON_COMPILING_IN_PYPY && !defined(PyByteArray_Check)

#define PyByteArray_Check(obj) PyObject_TypeCheck(obj, &PyByteArray_Type)

#endif

#if CYTHON_COMPILING_IN_PYPY && !defined(PyObject_Format)

#define PyObject_Format(obj, fmt) PyObject_CallMethod(obj, "__format__", "O", fmt)

#endif

#define __Pyx_PyString_FormatSafe(a, b) ((unlikely((a) == Py_None || (PyString_Check(b) && !PyString_CheckExact(b)))) ? PyNumber_Remainder(a, b) : __Pyx_PyString_Format(a, b))

#define __Pyx_PyUnicode_FormatSafe(a, b) ((unlikely((a) == Py_None || (PyUnicode_Check(b) && !PyUnicode_CheckExact(b)))) ? PyNumber_Remainder(a, b) : PyUnicode_Format(a, b))

#if PY_MAJOR_VERSION >= 3

#define __Pyx_PyString_Format(a, b) PyUnicode_Format(a, b)

#else

#define __Pyx_PyString_Format(a, b) PyString_Format(a, b)

#endif

#if PY_MAJOR_VERSION < 3 && !defined(PyObject_ASCII)

#define PyObject_ASCII(o) PyObject_Repr(o)

#endif

#if PY_MAJOR_VERSION >= 3

#define PyBaseString_Type PyUnicode_Type

#define PyStringObject PyUnicodeObject

#define PyString_Type PyUnicode_Type

#define PyString_Check PyUnicode_Check

#define PyString_CheckExact PyUnicode_CheckExact

#ifndef PyObject_Unicode

#define PyObject_Unicode PyObject_Str

#endif

#endif

#if PY_MAJOR_VERSION >= 3

#define __Pyx_PyBaseString_Check(obj) PyUnicode_Check(obj)

#define __Pyx_PyBaseString_CheckExact(obj) PyUnicode_CheckExact(obj)

#else

#define __Pyx_PyBaseString_Check(obj) (PyString_Check(obj) || PyUnicode_Check(obj))

#define __Pyx_PyBaseString_CheckExact(obj) (PyString_CheckExact(obj) || PyUnicode_CheckExact(obj))

#endif

#ifndef PySet_CheckExact

#define PySet_CheckExact(obj) (Py_TYPE(obj) == &PySet_Type)

#endif

#if PY_VERSION_HEX >= 0x030900A4

#define __Pyx_SET_REFCNT(obj, refcnt) Py_SET_REFCNT(obj, refcnt)

#define __Pyx_SET_SIZE(obj, size) Py_SET_SIZE(obj, size)

#else

#define __Pyx_SET_REFCNT(obj, refcnt) Py_REFCNT(obj) = (refcnt)

#define __Pyx_SET_SIZE(obj, size) Py_SIZE(obj) = (size)

#endif

#if CYTHON_ASSUME_SAFE_MACROS

#define __Pyx_PySequence_SIZE(seq) Py_SIZE(seq)

#else

#define __Pyx_PySequence_SIZE(seq) PySequence_Size(seq)

#endif

#if PY_MAJOR_VERSION >= 3

#define PyIntObject PyLongObject

#define PyInt_Type PyLong_Type

#define PyInt_Check(op) PyLong_Check(op)

#define PyInt_CheckExact(op) PyLong_CheckExact(op)

#define PyInt_FromString PyLong_FromString

#define PyInt_FromUnicode PyLong_FromUnicode

#define PyInt_FromLong PyLong_FromLong

#define PyInt_FromSize_t PyLong_FromSize_t

#define PyInt_FromSsize_t PyLong_FromSsize_t

#define PyInt_AsLong PyLong_AsLong

#define PyInt_AS_LONG PyLong_AS_LONG

#define PyInt_AsSsize_t PyLong_AsSsize_t

#define PyInt_AsUnsignedLongMask PyLong_AsUnsignedLongMask

#define PyInt_AsUnsignedLongLongMask PyLong_AsUnsignedLongLongMask

#define PyNumber_Int PyNumber_Long

#endif

#if PY_MAJOR_VERSION >= 3

#define PyBoolObject PyLongObject

#endif

#if PY_MAJOR_VERSION >= 3 && CYTHON_COMPILING_IN_PYPY

#ifndef PyUnicode_InternFromString

#define PyUnicode_InternFromString(s) PyUnicode_FromString(s)

#endif

#endif

#if PY_VERSION_HEX < 0x030200A4

typedef long Py_hash_t;

#define __Pyx_PyInt_FromHash_t PyInt_FromLong

#define __Pyx_PyInt_AsHash_t PyInt_AsLong

#else

#define __Pyx_PyInt_FromHash_t PyInt_FromSsize_t

#define __Pyx_PyInt_AsHash_t PyInt_AsSsize_t

#endif

#if PY_MAJOR_VERSION >= 3

#define __Pyx_PyMethod_New(func, self, klass) ((self) ? ((void)(klass), PyMethod_New(func, self)) : __Pyx_NewRef(func))

#else

#define __Pyx_PyMethod_New(func, self, klass) PyMethod_New(func, self, klass)

#endif

#if CYTHON_USE_ASYNC_SLOTS

#if PY_VERSION_HEX >= 0x030500B1

#define __Pyx_PyAsyncMethodsStruct PyAsyncMethods

#define __Pyx_PyType_AsAsync(obj) (Py_TYPE(obj)->tp_as_async)

#else

#define __Pyx_PyType_AsAsync(obj) ((__Pyx_PyAsyncMethodsStruct*) (Py_TYPE(obj)->tp_reserved))

#endif

#else

#define __Pyx_PyType_AsAsync(obj) NULL

#endif

#ifndef __Pyx_PyAsyncMethodsStruct

typedef struct {

unaryfunc am_await;

unaryfunc am_aiter;

unaryfunc am_anext;

} __Pyx_PyAsyncMethodsStruct;

#endif

#if defined(WIN32) || defined(MS_WINDOWS)

#define _USE_MATH_DEFINES

#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

#define __PYX_MARK_ERR_POS(f_index, lineno) \

{ __pyx_filename = __pyx_f[f_index]; (void)__pyx_filename; __pyx_lineno = lineno; (void)__pyx_lineno; __pyx_clineno = __LINE__; (void)__pyx_clineno; }

#define __PYX_ERR(f_index, lineno, Ln_error) \

{ __PYX_MARK_ERR_POS(f_index, lineno) goto Ln_error; }

#ifndef __PYX_EXTERN_C

#ifdef __cplusplus

#define __PYX_EXTERN_C extern "C"

#else

#define __PYX_EXTERN_C extern

#endif

#endif

#define __PYX_HAVE__ssh2__channel

#define __PYX_HAVE_API__ssh2__channel

/* Early includes */

#include <stddef.h>

#include <time.h>

#include <sys/types.h>

#include <sys/stat.h>

#include "libssh2.h"

#include <string.h>

#include <stdlib.h>

#include "find_eol.h"

#include "libssh2_sftp.h"

#ifdef _OPENMP

#include <omp.h>

#endif /* _OPENMP */

#if defined(PYREX_WITHOUT_ASSERTIONS) && !defined(CYTHON_WITHOUT_ASSERTIONS)

#define CYTHON_WITHOUT_ASSERTIONS

#endif

typedef struct {PyObject **p; const char *s; const Py_ssize_t n; const char* encoding;

const char is_unicode; const char is_str; const char intern; } __Pyx_StringTabEntry;

#define __PYX_DEFAULT_STRING_ENCODING_IS_ASCII 0

#define __PYX_DEFAULT_STRING_ENCODING_IS_UTF8 0

#define __PYX_DEFAULT_STRING_ENCODING_IS_DEFAULT (PY_MAJOR_VERSION >= 3 && __PYX_DEFAULT_STRING_ENCODING_IS_UTF8)

#define __PYX_DEFAULT_STRING_ENCODING ""

#define __Pyx_PyObject_FromString __Pyx_PyBytes_FromString

#define __Pyx_PyObject_FromStringAndSize __Pyx_PyBytes_FromStringAndSize

#define __Pyx_uchar_cast(c) ((unsigned char)c)

#define __Pyx_long_cast(x) ((long)x)

#define __Pyx_fits_Py_ssize_t(v, type, is_signed) (\

(sizeof(type) < sizeof(Py_ssize_t)) ||\

(sizeof(type) > sizeof(Py_ssize_t) &&\

likely(v < (type)PY_SSIZE_T_MAX ||\

v == (type)PY_SSIZE_T_MAX) &&\

(!is_signed || likely(v > (type)PY_SSIZE_T_MIN ||\

v == (type)PY_SSIZE_T_MIN))) ||\

(sizeof(type) == sizeof(Py_ssize_t) &&\

(is_signed || likely(v < (type)PY_SSIZE_T_MAX ||\

v == (type)PY_SSIZE_T_MAX))) )

static CYTHON_INLINE int __Pyx_is_valid_index(Py_ssize_t i, Py_ssize_t limit) {

return (size_t) i < (size_t) limit;

}

#if defined (__cplusplus) && __cplusplus >= 201103L

#include <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 const char* __Pyx_PyObject_AsString(PyObject*);

static CYTHON_INLINE const char* __Pyx_PyObject_AsStringAndSize(PyObject*, Py_ssize_t* length);

#define __Pyx_PyByteArray_FromString(s) PyByteArray_FromStringAndSize((const char*)s, strlen((const char*)s))

#define __Pyx_PyByteArray_FromStringAndSize(s, l) PyByteArray_FromStringAndSize((const char*)s, l)

#define __Pyx_PyBytes_FromString PyBytes_FromString

#define __Pyx_PyBytes_FromStringAndSize PyBytes_FromStringAndSize

static CYTHON_INLINE PyObject* __Pyx_PyUnicode_FromString(const char*);

#if PY_MAJOR_VERSION < 3

#define __Pyx_PyStr_FromString __Pyx_PyBytes_FromString

#define __Pyx_PyStr_FromStringAndSize __Pyx_PyBytes_FromStringAndSize

#else

#define __Pyx_PyStr_FromString __Pyx_PyUnicode_FromString

#define __Pyx_PyStr_FromStringAndSize __Pyx_PyUnicode_FromStringAndSize

#endif

#define __Pyx_PyBytes_AsWritableString(s) ((char*) PyBytes_AS_STRING(s))

#define __Pyx_PyBytes_AsWritableSString(s) ((signed char*) PyBytes_AS_STRING(s))

#define __Pyx_PyBytes_AsWritableUString(s) ((unsigned char*) PyBytes_AS_STRING(s))

#define __Pyx_PyBytes_AsString(s) ((const char*) PyBytes_AS_STRING(s))

#define __Pyx_PyBytes_AsSString(s) ((const signed char*) PyBytes_AS_STRING(s))

#define __Pyx_PyBytes_AsUString(s) ((const unsigned char*) PyBytes_AS_STRING(s))

#define __Pyx_PyObject_AsWritableString(s) ((char*) __Pyx_PyObject_AsString(s))

#define __Pyx_PyObject_AsWritableSString(s) ((signed char*) __Pyx_PyObject_AsString(s))

#define __Pyx_PyObject_AsWritableUString(s) ((unsigned char*) __Pyx_PyObject_AsString(s))

#define __Pyx_PyObject_AsSString(s) ((const signed char*) __Pyx_PyObject_AsString(s))

#define __Pyx_PyObject_AsUString(s) ((const unsigned char*) __Pyx_PyObject_AsString(s))

#define __Pyx_PyObject_FromCString(s) __Pyx_PyObject_FromString((const char*)s)

#define __Pyx_PyBytes_FromCString(s) __Pyx_PyBytes_FromString((const char*)s)

#define __Pyx_PyByteArray_FromCString(s) __Pyx_PyByteArray_FromString((const char*)s)

#define __Pyx_PyStr_FromCString(s) __Pyx_PyStr_FromString((const char*)s)

#define __Pyx_PyUnicode_FromCString(s) __Pyx_PyUnicode_FromString((const char*)s)

static CYTHON_INLINE size_t __Pyx_Py_UNICODE_strlen(const Py_UNICODE *u) {

const Py_UNICODE *u_end = u;

while (*u_end++) ;

return (size_t)(u_end - u - 1);

}

#define __Pyx_PyUnicode_FromUnicode(u) PyUnicode_FromUnicode(u, __Pyx_Py_UNICODE_strlen(u))

#define __Pyx_PyUnicode_FromUnicodeAndLength PyUnicode_FromUnicode

#define __Pyx_PyUnicode_AsUnicode PyUnicode_AsUnicode

#define __Pyx_NewRef(obj) (Py_INCREF(obj), obj)

#define __Pyx_Owned_Py_None(b) __Pyx_NewRef(Py_None)

static CYTHON_INLINE PyObject * __Pyx_PyBool_FromLong(long b);

static CYTHON_INLINE int __Pyx_PyObject_IsTrue(PyObject*);

static CYTHON_INLINE int __Pyx_PyObject_IsTrueAndDecref(PyObject*);

static CYTHON_INLINE PyObject* __Pyx_PyNumber_IntOrLong(PyObject* x);

#define __Pyx_PySequence_Tuple(obj)\

(likely(PyTuple_CheckExact(obj)) ? __Pyx_NewRef(obj) : PySequence_Tuple(obj))

static CYTHON_INLINE Py_ssize_t __Pyx_PyIndex_AsSsize_t(PyObject*);

static CYTHON_INLINE PyObject * __Pyx_PyInt_FromSize_t(size_t);

#if CYTHON_ASSUME_SAFE_MACROS

#define __pyx_PyFloat_AsDouble(x) (PyFloat_CheckExact(x) ? PyFloat_AS_DOUBLE(x) : PyFloat_AsDouble(x))

#else

#define __pyx_PyFloat_AsDouble(x) PyFloat_AsDouble(x)

#endif

#define __pyx_PyFloat_AsFloat(x) ((float) __pyx_PyFloat_AsDouble(x))

#if PY_MAJOR_VERSION >= 3

#define __Pyx_PyNumber_Int(x) (PyLong_CheckExact(x) ? __Pyx_NewRef(x) : PyNumber_Long(x))

#else

#define __Pyx_PyNumber_Int(x) (PyInt_CheckExact(x) ? __Pyx_NewRef(x) : PyNumber_Int(x))

#endif

#define __Pyx_PyNumber_Float(x) (PyFloat_CheckExact(x) ? __Pyx_NewRef(x) : PyNumber_Float(x))

#if PY_MAJOR_VERSION < 3 && __PYX_DEFAULT_STRING_ENCODING_IS_ASCII

static int __Pyx_sys_getdefaultencoding_not_ascii;

static int __Pyx_init_sys_getdefaultencoding_params(void) {

PyObject* sys;

PyObject* default_encoding = NULL;

PyObject* ascii_chars_u = NULL;

PyObject* ascii_chars_b = NULL;

const char* default_encoding_c;

sys = PyImport_ImportModule("sys");

if (!sys) goto bad;

default_encoding = PyObject_CallMethod(sys, (char*) "getdefaultencoding", NULL);

Py_DECREF(sys);

if (!default_encoding) goto bad;

default_encoding_c = PyBytes_AsString(default_encoding);

if (!default_encoding_c) goto bad;

if (strcmp(default_encoding_c, "ascii") == 0) {

__Pyx_sys_getdefaultencoding_not_ascii = 0;

} else {

char ascii_chars[128];

int c;

for (c = 0; c < 128; c++) {

ascii_chars[c] = c;

}

__Pyx_sys_getdefaultencoding_not_ascii = 1;

ascii_chars_u = PyUnicode_DecodeASCII(ascii_chars, 128, NULL);

if (!ascii_chars_u) goto bad;

ascii_chars_b = PyUnicode_AsEncodedString(ascii_chars_u, default_encoding_c, NULL);

if (!ascii_chars_b || !PyBytes_Check(ascii_chars_b) || memcmp(ascii_chars, PyBytes_AS_STRING(ascii_chars_b), 128) != 0) {

PyErr_Format(

PyExc_ValueError,

"This module compiled with c_string_encoding=ascii, but default encoding '%.200s' is not a superset of ascii.",

default_encoding_c);

goto bad;

}

Py_DECREF(ascii_chars_u);

Py_DECREF(ascii_chars_b);

}

Py_DECREF(default_encoding);

return 0;

bad:

Py_XDECREF(default_encoding);

Py_XDECREF(ascii_chars_u);

Py_XDECREF(ascii_chars_b);

return -1;

}

#endif

#if __PYX_DEFAULT_STRING_ENCODING_IS_DEFAULT && PY_MAJOR_VERSION >= 3

#define __Pyx_PyUnicode_FromStringAndSize(c_str, size) PyUnicode_DecodeUTF8(c_str, size, NULL)

#else

#define __Pyx_PyUnicode_FromStringAndSize(c_str, size) PyUnicode_Decode(c_str, size, __PYX_DEFAULT_STRING_ENCODING, NULL)

#if __PYX_DEFAULT_STRING_ENCODING_IS_DEFAULT

static char* __PYX_DEFAULT_STRING_ENCODING;

static int __Pyx_init_sys_getdefaultencoding_params(void) {

PyObject* sys;

PyObject* default_encoding = NULL;

char* default_encoding_c;

sys = PyImport_ImportModule("sys");

if (!sys) goto bad;

default_encoding = PyObject_CallMethod(sys, (char*) (const char*) "getdefaultencoding", NULL);

Py_DECREF(sys);

if (!default_encoding) goto bad;

default_encoding_c = PyBytes_AsString(default_encoding);

if (!default_encoding_c) goto bad;

__PYX_DEFAULT_STRING_ENCODING = (char*) malloc(strlen(default_encoding_c) + 1);

if (!__PYX_DEFAULT_STRING_ENCODING) goto bad;

strcpy(__PYX_DEFAULT_STRING_ENCODING, default_encoding_c);

Py_DECREF(default_encoding);

return 0;

bad:

Py_XDECREF(default_encoding);

return -1;

}

#endif

#endif

/* Test for GCC > 2.95 */

#if defined(__GNUC__) && (__GNUC__ > 2 || (__GNUC__ == 2 && (__GNUC_MINOR__ > 95)))

#define likely(x) __builtin_expect(!!(x), 1)

#define unlikely(x) __builtin_expect(!!(x), 0)

#else /* !__GNUC__ or GCC < 2.95 */

#define likely(x) (x)

#define unlikely(x) (x)

#endif /* __GNUC__ */

static CYTHON_INLINE void __Pyx_pretend_to_initialize(void* ptr) { (void)ptr; }

static PyObject *__pyx_m = NULL;

static PyObject *__pyx_d;

static PyObject *__pyx_b;

static PyObject *__pyx_cython_runtime = NULL;

static PyObject *__pyx_empty_tuple;

static PyObject *__pyx_empty_bytes;

static PyObject *__pyx_empty_unicode;

static int __pyx_lineno;

static int __pyx_clineno = 0;

static const char * __pyx_cfilenm= __FILE__;

static const char *__pyx_filename;

static const char *__pyx_f[] = {

"ssh2/channel.pyx",

"stringsource",

"ssh2/session.pxd",

"ssh2/sftp.pxd",

};

/* NoFastGil.proto */

#define __Pyx_PyGILState_Ensure PyGILState_Ensure

#define __Pyx_PyGILState_Release PyGILState_Release

#define __Pyx_FastGIL_Remember()

#define __Pyx_FastGIL_Forget()

#define __Pyx_FastGilFuncInit()

/* ForceInitThreads.proto */

#ifndef __PYX_FORCE_INIT_THREADS

#define __PYX_FORCE_INIT_THREADS 0

#endif

/*--- Type declarations ---*/

struct __pyx_obj_4ssh2_7session_Session;

struct __pyx_obj_4ssh2_4sftp_SFTP;

struct __pyx_obj_4ssh2_7channel_Channel;

/* "session.pxd":19

* cimport c_ssh2

*

* cdef class Session: # <<<<<<<<<<<<<<

* cdef c_ssh2.LIBSSH2_SESSION *_session

* cdef int _sock

*/

struct __pyx_obj_4ssh2_7session_Session {

PyObject_HEAD

LIBSSH2_SESSION *_session;

int _sock;

PyObject *sock;

PyObject *_kbd_callback;

};

/* "sftp.pxd":26

*

*

* cdef class SFTP: # <<<<<<<<<<<<<<

* cdef c_sftp.LIBSSH2_SFTP *_sftp

* cdef Session _session

*/

struct __pyx_obj_4ssh2_4sftp_SFTP {

PyObject_HEAD

LIBSSH2_SFTP *_sftp;

struct __pyx_obj_4ssh2_7session_Session *_session;

};

/* "ssh2/channel.pxd":24

*

*

* cdef class Channel: # <<<<<<<<<<<<<<

* cdef c_ssh2.LIBSSH2_CHANNEL *_channel

* cdef Session _session

*/

struct __pyx_obj_4ssh2_7channel_Channel {

PyObject_HEAD

LIBSSH2_CHANNEL *_channel;

struct __pyx_obj_4ssh2_7session_Session *_session;

};

/* --- Runtime support code (head) --- */

/* Refnanny.proto */

#ifndef CYTHON_REFNANNY

#define CYTHON_REFNANNY 0

#endif

#if CYTHON_REFNANNY

typedef struct {

void (*INCREF)(void*, PyObject*, int);

void (*DECREF)(void*, PyObject*, int);

void (*GOTREF)(void*, PyObject*, int);

void (*GIVEREF)(void*, PyObject*, int);

void* (*SetupContext)(const char*, int, const char*);

void (*FinishContext)(void**);

} __Pyx_RefNannyAPIStruct;

static __Pyx_RefNannyAPIStruct *__Pyx_RefNanny = NULL;

static __Pyx_RefNannyAPIStruct *__Pyx_RefNannyImportAPI(const char *modname);

#define __Pyx_RefNannyDeclarations void *__pyx_refnanny = NULL;

#ifdef WITH_THREAD

#define __Pyx_RefNannySetupContext(name, acquire_gil)\

if (acquire_gil) {\

PyGILState_STATE __pyx_gilstate_save = PyGILState_Ensure();\

__pyx_refnanny = __Pyx_RefNanny->SetupContext((name), __LINE__, __FILE__);\

PyGILState_Release(__pyx_gilstate_save);\

} else {\

__pyx_refnanny = __Pyx_RefNanny->SetupContext((name), __LINE__, __FILE__);\

}

#else

#define __Pyx_RefNannySetupContext(name, acquire_gil)\

__pyx_refnanny = __Pyx_RefNanny->SetupContext((name), __LINE__, __FILE__)

#endif

#define __Pyx_RefNannyFinishContext()\

__Pyx_RefNanny->FinishContext(&__pyx_refnanny)

#define __Pyx_INCREF(r) __Pyx_RefNanny->INCREF(__pyx_refnanny, (PyObject *)(r), __LINE__)

#define __Pyx_DECREF(r) __Pyx_RefNanny->DECREF(__pyx_refnanny, (PyObject *)(r), __LINE__)

#define __Pyx_GOTREF(r) __Pyx_RefNanny->GOTREF(__pyx_refnanny, (PyObject *)(r), __LINE__)

#define __Pyx_GIVEREF(r) __Pyx_RefNanny->GIVEREF(__pyx_refnanny, (PyObject *)(r), __LINE__)

#define __Pyx_XINCREF(r) do { if((r) != NULL) {__Pyx_INCREF(r); }} while(0)

#define __Pyx_XDECREF(r) do { if((r) != NULL) {__Pyx_DECREF(r); }} while(0)

#define __Pyx_XGOTREF(r) do { if((r) != NULL) {__Pyx_GOTREF(r); }} while(0)

#define __Pyx_XGIVEREF(r) do { if((r) != NULL) {__Pyx_GIVEREF(r);}} while(0)

#else

#define __Pyx_RefNannyDeclarations

#define __Pyx_RefNannySetupContext(name, acquire_gil)

#define __Pyx_RefNannyFinishContext()

#define __Pyx_INCREF(r) Py_INCREF(r)

#define __Pyx_DECREF(r) Py_DECREF(r)

#define __Pyx_GOTREF(r)

#define __Pyx_GIVEREF(r)

#define __Pyx_XINCREF(r) Py_XINCREF(r)

#define __Pyx_XDECREF(r) Py_XDECREF(r)

#define __Pyx_XGOTREF(r)

#define __Pyx_XGIVEREF(r)

#endif

#define __Pyx_XDECREF_SET(r, v) do {\

PyObject *tmp = (PyObject *) r;\

r = v; __Pyx_XDECREF(tmp);\

} while (0)

#define __Pyx_DECREF_SET(r, v) do {\

PyObject *tmp = (PyObject *) r;\

r = v; __Pyx_DECREF(tmp);\

} while (0)

#define __Pyx_CLEAR(r) do { PyObject* tmp = ((PyObject*)(r)); r = NULL; __Pyx_DECREF(tmp);} while(0)

#define __Pyx_XCLEAR(r) do { if((r) != NULL) {PyObject* tmp = ((PyObject*)(r)); r = NULL; __Pyx_DECREF(tmp);}} while(0)

/* PyObjectGetAttrStr.proto */

#if CYTHON_USE_TYPE_SLOTS

static CYTHON_INLINE PyObject* __Pyx_PyObject_GetAttrStr(PyObject* obj, PyObject* attr_name);

#else

#define __Pyx_PyObject_GetAttrStr(o,n) PyObject_GetAttr(o,n)

#endif

/* GetBuiltinName.proto */

static PyObject *__Pyx_GetBuiltinName(PyObject *name);

/* RaiseDoubleKeywords.proto */

static void __Pyx_RaiseDoubleKeywordsError(const char* func_name, PyObject* kw_name);

/* ParseKeywords.proto */

static int __Pyx_ParseOptionalKeywords(PyObject *kwds, PyObject **argnames[],\

PyObject *kwds2, PyObject *values[], Py_ssize_t num_pos_args,\

const char* function_name);

/* RaiseArgTupleInvalid.proto */

static void __Pyx_RaiseArgtupleInvalid(const char* func_name, int exact,

Py_ssize_t num_min, Py_ssize_t num_max, Py_ssize_t num_found);

/* ArgTypeTest.proto */

#define __Pyx_ArgTypeTest(obj, type, none_allowed, name, exact)\

((likely((Py_TYPE(obj) == type) | (none_allowed && (obj == Py_None)))) ? 1 :\

__Pyx__ArgTypeTest(obj, type, name, exact))

static int __Pyx__ArgTypeTest(PyObject *obj, PyTypeObject *type, const char *name, int exact);

/* 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

/* PyThreadStateGet.proto */

#if CYTHON_FAST_THREAD_STATE

#define __Pyx_PyThreadState_declare PyThreadState *__pyx_tstate;

#define __Pyx_PyThreadState_assign __pyx_tstate = __Pyx_PyThreadState_Current;

#define __Pyx_PyErr_Occurred() __pyx_tstate->curexc_type

#else

#define __Pyx_PyThreadState_declare

#define __Pyx_PyThreadState_assign

#define __Pyx_PyErr_Occurred() PyErr_Occurred()

#endif