#ifndef PY_SSIZE_T_CLEAN

#define PY_SSIZE_T_CLEAN

#endif /* PY_SSIZE_T_CLEAN */

#include "Python.h"

#ifndef Py_PYTHON_H

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

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

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

#define CYTHON_ABI "0_29_32"

#define CYTHON_HEX_VERSION 0x001D20F0

#define CYTHON_FUTURE_DIVISION 0

#include <stddef.h>

#ifndef offsetof

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

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

#ifndef __stdcall

#define __stdcall

#endif

#ifndef __cdecl

#define __cdecl

#endif

#ifndef __fastcall

#define __fastcall

#endif

#ifndef DL_IMPORT

#define DL_IMPORT(t) t

#ifndef DL_EXPORT

#define DL_EXPORT(t) t

#define __PYX_COMMA ,

#ifndef HAVE_LONG_LONG

#if PY_VERSION_HEX >= 0x02070000

#define HAVE_LONG_LONG

#endif

#ifndef PY_LONG_LONG

#define PY_LONG_LONG LONG_LONG

#ifndef Py_HUGE_VAL

#define Py_HUGE_VAL HUGE_VAL

#ifdef PYPY_VERSION

#define CYTHON_COMPILING_IN_PYPY 1

#define CYTHON_COMPILING_IN_PYSTON 0

#define CYTHON_COMPILING_IN_CPYTHON 0

#define CYTHON_COMPILING_IN_NOGIL 0

#undef CYTHON_USE_TYPE_SLOTS

#define CYTHON_USE_TYPE_SLOTS 0

#undef CYTHON_USE_PYTYPE_LOOKUP

#define CYTHON_USE_PYTYPE_LOOKUP 0

#if PY_VERSION_HEX < 0x03050000

#undef CYTHON_USE_ASYNC_SLOTS

#define CYTHON_USE_ASYNC_SLOTS 0

#elif !defined(CYTHON_USE_ASYNC_SLOTS)

#define CYTHON_USE_ASYNC_SLOTS 1

#endif

#undef CYTHON_USE_PYLIST_INTERNALS

#define CYTHON_USE_PYLIST_INTERNALS 0

#undef CYTHON_USE_UNICODE_INTERNALS

#define CYTHON_USE_UNICODE_INTERNALS 0

#undef CYTHON_USE_UNICODE_WRITER

#define CYTHON_USE_UNICODE_WRITER 0

#undef CYTHON_USE_PYLONG_INTERNALS

#define CYTHON_USE_PYLONG_INTERNALS 0

#undef CYTHON_AVOID_BORROWED_REFS

#define CYTHON_AVOID_BORROWED_REFS 1

#undef CYTHON_ASSUME_SAFE_MACROS

#define CYTHON_ASSUME_SAFE_MACROS 0

#undef CYTHON_UNPACK_METHODS

#define CYTHON_UNPACK_METHODS 0

#undef CYTHON_FAST_THREAD_STATE

#define CYTHON_FAST_THREAD_STATE 0

#undef CYTHON_FAST_PYCALL

#define CYTHON_FAST_PYCALL 0

#undef CYTHON_PEP489_MULTI_PHASE_INIT

#define CYTHON_PEP489_MULTI_PHASE_INIT 0

#undef CYTHON_USE_TP_FINALIZE

#define CYTHON_USE_TP_FINALIZE 0

#undef CYTHON_USE_DICT_VERSIONS

#define CYTHON_USE_DICT_VERSIONS 0

#undef CYTHON_USE_EXC_INFO_STACK

#define CYTHON_USE_EXC_INFO_STACK 0

#ifndef CYTHON_UPDATE_DESCRIPTOR_DOC

#define CYTHON_UPDATE_DESCRIPTOR_DOC (PYPY_VERSION_HEX >= 0x07030900)

#endif

#elif defined(PYSTON_VERSION)

#define CYTHON_COMPILING_IN_PYPY 0

#define CYTHON_COMPILING_IN_PYSTON 1

#define CYTHON_COMPILING_IN_CPYTHON 0

#define CYTHON_COMPILING_IN_NOGIL 0

#ifndef CYTHON_USE_TYPE_SLOTS

#define CYTHON_USE_TYPE_SLOTS 1

#endif

#undef CYTHON_USE_PYTYPE_LOOKUP

#define CYTHON_USE_PYTYPE_LOOKUP 0

#undef CYTHON_USE_ASYNC_SLOTS

#define CYTHON_USE_ASYNC_SLOTS 0

#undef CYTHON_USE_PYLIST_INTERNALS

#define CYTHON_USE_PYLIST_INTERNALS 0

#ifndef CYTHON_USE_UNICODE_INTERNALS

#define CYTHON_USE_UNICODE_INTERNALS 1

#endif

#undef CYTHON_USE_UNICODE_WRITER

#define CYTHON_USE_UNICODE_WRITER 0

#undef CYTHON_USE_PYLONG_INTERNALS

#define CYTHON_USE_PYLONG_INTERNALS 0

#ifndef CYTHON_AVOID_BORROWED_REFS

#define CYTHON_AVOID_BORROWED_REFS 0

#endif

#ifndef CYTHON_ASSUME_SAFE_MACROS

#define CYTHON_ASSUME_SAFE_MACROS 1

#endif

#ifndef CYTHON_UNPACK_METHODS

#define CYTHON_UNPACK_METHODS 1

#endif

#undef CYTHON_FAST_THREAD_STATE

#define CYTHON_FAST_THREAD_STATE 0

#undef CYTHON_FAST_PYCALL

#define CYTHON_FAST_PYCALL 0

#undef CYTHON_PEP489_MULTI_PHASE_INIT

#define CYTHON_PEP489_MULTI_PHASE_INIT 0

#undef CYTHON_USE_TP_FINALIZE

#define CYTHON_USE_TP_FINALIZE 0

#undef CYTHON_USE_DICT_VERSIONS

#define CYTHON_USE_DICT_VERSIONS 0

#undef CYTHON_USE_EXC_INFO_STACK

#define CYTHON_USE_EXC_INFO_STACK 0

#ifndef CYTHON_UPDATE_DESCRIPTOR_DOC

#define CYTHON_UPDATE_DESCRIPTOR_DOC 0

#endif

#elif defined(PY_NOGIL)

#define CYTHON_COMPILING_IN_PYPY 0

#define CYTHON_COMPILING_IN_PYSTON 0

#define CYTHON_COMPILING_IN_CPYTHON 0

#define CYTHON_COMPILING_IN_NOGIL 1

#ifndef CYTHON_USE_TYPE_SLOTS

#define CYTHON_USE_TYPE_SLOTS 1

#endif

#undef CYTHON_USE_PYTYPE_LOOKUP

#define CYTHON_USE_PYTYPE_LOOKUP 0

#ifndef CYTHON_USE_ASYNC_SLOTS

#define CYTHON_USE_ASYNC_SLOTS 1

#endif

#undef CYTHON_USE_PYLIST_INTERNALS

#define CYTHON_USE_PYLIST_INTERNALS 0

#ifndef CYTHON_USE_UNICODE_INTERNALS

#define CYTHON_USE_UNICODE_INTERNALS 1

#endif

#undef CYTHON_USE_UNICODE_WRITER

#define CYTHON_USE_UNICODE_WRITER 0

#undef CYTHON_USE_PYLONG_INTERNALS

#define CYTHON_USE_PYLONG_INTERNALS 0

#ifndef CYTHON_AVOID_BORROWED_REFS

#define CYTHON_AVOID_BORROWED_REFS 0

#endif

#ifndef CYTHON_ASSUME_SAFE_MACROS

#define CYTHON_ASSUME_SAFE_MACROS 1

#endif

#ifndef CYTHON_UNPACK_METHODS

#define CYTHON_UNPACK_METHODS 1

#endif

#undef CYTHON_FAST_THREAD_STATE

#define CYTHON_FAST_THREAD_STATE 0

#undef CYTHON_FAST_PYCALL

#define CYTHON_FAST_PYCALL 0

#ifndef CYTHON_PEP489_MULTI_PHASE_INIT

#define CYTHON_PEP489_MULTI_PHASE_INIT 1

#endif

#ifndef CYTHON_USE_TP_FINALIZE

#define CYTHON_USE_TP_FINALIZE 1

#endif

#undef CYTHON_USE_DICT_VERSIONS

#define CYTHON_USE_DICT_VERSIONS 0

#undef CYTHON_USE_EXC_INFO_STACK

#define CYTHON_USE_EXC_INFO_STACK 0

#define CYTHON_COMPILING_IN_PYPY 0

#define CYTHON_COMPILING_IN_PYSTON 0

#define CYTHON_COMPILING_IN_CPYTHON 1

#define CYTHON_COMPILING_IN_NOGIL 0

#ifndef CYTHON_USE_TYPE_SLOTS

#define CYTHON_USE_TYPE_SLOTS 1

#endif

#if PY_VERSION_HEX < 0x02070000

#undef CYTHON_USE_PYTYPE_LOOKUP

#define CYTHON_USE_PYTYPE_LOOKUP 0

#elif !defined(CYTHON_USE_PYTYPE_LOOKUP)

#define CYTHON_USE_PYTYPE_LOOKUP 1

#endif

#if PY_MAJOR_VERSION < 3

#undef CYTHON_USE_ASYNC_SLOTS

#define CYTHON_USE_ASYNC_SLOTS 0

#elif !defined(CYTHON_USE_ASYNC_SLOTS)

#define CYTHON_USE_ASYNC_SLOTS 1

#endif

#if PY_VERSION_HEX < 0x02070000

#undef CYTHON_USE_PYLONG_INTERNALS

#define CYTHON_USE_PYLONG_INTERNALS 0

#elif !defined(CYTHON_USE_PYLONG_INTERNALS)

#define CYTHON_USE_PYLONG_INTERNALS 1

#endif

#ifndef CYTHON_USE_PYLIST_INTERNALS

#define CYTHON_USE_PYLIST_INTERNALS 1

#endif

#ifndef CYTHON_USE_UNICODE_INTERNALS

#define CYTHON_USE_UNICODE_INTERNALS 1

#endif

#if PY_VERSION_HEX < 0x030300F0 || PY_VERSION_HEX >= 0x030B00A2

#undef CYTHON_USE_UNICODE_WRITER

#define CYTHON_USE_UNICODE_WRITER 0

#elif !defined(CYTHON_USE_UNICODE_WRITER)

#define CYTHON_USE_UNICODE_WRITER 1

#endif

#ifndef CYTHON_AVOID_BORROWED_REFS

#define CYTHON_AVOID_BORROWED_REFS 0

#endif

#ifndef CYTHON_ASSUME_SAFE_MACROS

#define CYTHON_ASSUME_SAFE_MACROS 1

#endif

#ifndef CYTHON_UNPACK_METHODS

#define CYTHON_UNPACK_METHODS 1

#endif

#if PY_VERSION_HEX >= 0x030B00A4

#undef CYTHON_FAST_THREAD_STATE

#define CYTHON_FAST_THREAD_STATE 0

#elif !defined(CYTHON_FAST_THREAD_STATE)

#define CYTHON_FAST_THREAD_STATE 1

#endif

#ifndef CYTHON_FAST_PYCALL

#define CYTHON_FAST_PYCALL (PY_VERSION_HEX < 0x030A0000)

#endif

#ifndef CYTHON_PEP489_MULTI_PHASE_INIT

#define CYTHON_PEP489_MULTI_PHASE_INIT (PY_VERSION_HEX >= 0x03050000)

#endif

#ifndef CYTHON_USE_TP_FINALIZE

#define CYTHON_USE_TP_FINALIZE (PY_VERSION_HEX >= 0x030400a1)

#endif

#ifndef CYTHON_USE_DICT_VERSIONS

#define CYTHON_USE_DICT_VERSIONS (PY_VERSION_HEX >= 0x030600B1)

#endif

#if PY_VERSION_HEX >= 0x030B00A4

#undef CYTHON_USE_EXC_INFO_STACK

#define CYTHON_USE_EXC_INFO_STACK 0

#elif !defined(CYTHON_USE_EXC_INFO_STACK)

#define CYTHON_USE_EXC_INFO_STACK (PY_VERSION_HEX >= 0x030700A3)

#endif

#ifndef CYTHON_UPDATE_DESCRIPTOR_DOC

#define CYTHON_UPDATE_DESCRIPTOR_DOC 1

#endif

#if !defined(CYTHON_FAST_PYCCALL)

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

#if CYTHON_USE_PYLONG_INTERNALS

#if PY_MAJOR_VERSION < 3

#include "longintrepr.h"

#endif

#undef SHIFT

#undef BASE

#undef MASK

#ifdef SIZEOF_VOID_P

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

#endif

#ifndef __has_attribute

#define __has_attribute(x) 0

#ifndef __has_cpp_attribute

#define __has_cpp_attribute(x) 0

#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

#ifndef CYTHON_UNUSED

# if defined(__GNUC__)

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

# define CYTHON_UNUSED __attribute__ ((__unused__))

# define CYTHON_UNUSED

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

# define CYTHON_UNUSED __attribute__ ((__unused__))

# define CYTHON_UNUSED

#ifndef CYTHON_MAYBE_UNUSED_VAR

# if defined(__cplusplus)

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

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

#ifndef CYTHON_NCP_UNUSED

# if CYTHON_COMPILING_IN_CPYTHON

# define CYTHON_NCP_UNUSED

# define CYTHON_NCP_UNUSED CYTHON_UNUSED

#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

#include <stdint.h>

#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

#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

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

#define Py_OptimizeFlag 0

#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

#define __Pyx_BUILTIN_MODULE_NAME "builtins"

#define __Pyx_DefaultClassType PyType_Type

#if PY_VERSION_HEX >= 0x030B00A1

static CYTHON_INLINE PyCodeObject* __Pyx_PyCode_New(int a, int k, int l, int s, int f,

PyObject *code, PyObject *c, PyObject* n, PyObject *v,

PyObject *fv, PyObject *cell, PyObject* fn,

PyObject *name, int fline, PyObject *lnos) {

PyObject *kwds=NULL, *argcount=NULL, *posonlyargcount=NULL, *kwonlyargcount=NULL;

PyObject *nlocals=NULL, *stacksize=NULL, *flags=NULL, *replace=NULL, *call_result=NULL, *empty=NULL;

const char *fn_cstr=NULL;

const char *name_cstr=NULL;

PyCodeObject* co=NULL;

PyObject *type, *value, *traceback;

PyErr_Fetch(&type, &value, &traceback);

if (!(kwds=PyDict_New())) goto end;

if (!(argcount=PyLong_FromLong(a))) goto end;

if (PyDict_SetItemString(kwds, "co_argcount", argcount) != 0) goto end;

if (!(posonlyargcount=PyLong_FromLong(0))) goto end;

if (PyDict_SetItemString(kwds, "co_posonlyargcount", posonlyargcount) != 0) goto end;

if (!(kwonlyargcount=PyLong_FromLong(k))) goto end;

if (PyDict_SetItemString(kwds, "co_kwonlyargcount", kwonlyargcount) != 0) goto end;

if (!(nlocals=PyLong_FromLong(l))) goto end;

if (PyDict_SetItemString(kwds, "co_nlocals", nlocals) != 0) goto end;

if (!(stacksize=PyLong_FromLong(s))) goto end;

if (PyDict_SetItemString(kwds, "co_stacksize", stacksize) != 0) goto end;

if (!(flags=PyLong_FromLong(f))) goto end;

if (PyDict_SetItemString(kwds, "co_flags", flags) != 0) goto end;

if (PyDict_SetItemString(kwds, "co_code", code) != 0) goto end;

if (PyDict_SetItemString(kwds, "co_consts", c) != 0) goto end;

if (PyDict_SetItemString(kwds, "co_names", n) != 0) goto end;

if (PyDict_SetItemString(kwds, "co_varnames", v) != 0) goto end;

if (PyDict_SetItemString(kwds, "co_freevars", fv) != 0) goto end;

if (PyDict_SetItemString(kwds, "co_cellvars", cell) != 0) goto end;

if (PyDict_SetItemString(kwds, "co_linetable", lnos) != 0) goto end;

if (!(fn_cstr=PyUnicode_AsUTF8AndSize(fn, NULL))) goto end;

if (!(name_cstr=PyUnicode_AsUTF8AndSize(name, NULL))) goto end;

if (!(co = PyCode_NewEmpty(fn_cstr, name_cstr, fline))) goto end;

if (!(replace = PyObject_GetAttrString((PyObject*)co, "replace"))) goto cleanup_code_too;

if (!(empty = PyTuple_New(0))) goto cleanup_code_too; // unfortunately __pyx_empty_tuple isn't available here

if (!(call_result = PyObject_Call(replace, empty, kwds))) goto cleanup_code_too;

Py_XDECREF((PyObject*)co);

co = (PyCodeObject*)call_result;

call_result = NULL;

if (0) {

cleanup_code_too:

Py_XDECREF((PyObject*)co);

co = NULL;

}

end:

Py_XDECREF(kwds);

Py_XDECREF(argcount);

Py_XDECREF(posonlyargcount);

Py_XDECREF(kwonlyargcount);

Py_XDECREF(nlocals);

Py_XDECREF(stacksize);

Py_XDECREF(replace);

Py_XDECREF(call_result);

Py_XDECREF(empty);

if (type) {

PyErr_Restore(type, value, traceback);

}

return co;

}

#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 PyType_Type

#ifndef Py_TPFLAGS_CHECKTYPES

#define Py_TPFLAGS_CHECKTYPES 0

#ifndef Py_TPFLAGS_HAVE_INDEX

#define Py_TPFLAGS_HAVE_INDEX 0

#ifndef Py_TPFLAGS_HAVE_NEWBUFFER

#define Py_TPFLAGS_HAVE_NEWBUFFER 0

#ifndef Py_TPFLAGS_HAVE_FINALIZE

#define Py_TPFLAGS_HAVE_FINALIZE 0

#ifndef METH_STACKLESS

#define METH_STACKLESS 0

#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);

#define __Pyx_PyCFunctionFast _PyCFunctionFast

#define __Pyx_PyCFunctionFastWithKeywords _PyCFunctionFastWithKeywords

#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)))))

#define __Pyx_PyFastCFunction_Check(func) 0

#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)

#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)

#if CYTHON_COMPILING_IN_PYSTON

#define __Pyx_PyCode_HasFreeVars(co) PyCode_HasFreeVars(co)

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

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

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

#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()

#define __Pyx_PyThreadState_Current _PyThreadState_Current

#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);

}

#if CYTHON_COMPILING_IN_CPYTHON || defined(_PyDict_NewPresized)

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

#define __Pyx_PyDict_NewPresized(n) PyDict_New()

#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)

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

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

#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)

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

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

#define CYTHON_PEP393_ENABLED 1

#if defined(PyUnicode_IS_READY)

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

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

#else

#define __Pyx_PyUnicode_READY(op) (0)

#endif

#define __Pyx_PyUnicode_GET_LENGTH(u) PyUnicode_GET_LENGTH(u)

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

#define __Pyx_PyUnicode_MAX_CHAR_VALUE(u) PyUnicode_MAX_CHAR_VALUE(u)

#define __Pyx_PyUnicode_KIND(u) PyUnicode_KIND(u)

#define __Pyx_PyUnicode_DATA(u) PyUnicode_DATA(u)

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

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

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

#if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x03090000

#define __Pyx_PyUnicode_IS_TRUE(u) (0 != (likely(PyUnicode_IS_READY(u)) ? PyUnicode_GET_LENGTH(u) : ((PyCompactUnicodeObject *)(u))->wstr_length))

#else

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

#endif

#else

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

#endif

#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))

#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)

#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))

#if CYTHON_COMPILING_IN_PYPY && !defined(PyUnicode_Contains)

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

#if CYTHON_COMPILING_IN_PYPY && !defined(PyByteArray_Check)

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

#if CYTHON_COMPILING_IN_PYPY && !defined(PyObject_Format)

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

#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)

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

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

#define PyObject_ASCII(o) PyObject_Repr(o)

#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

#if PY_MAJOR_VERSION >= 3

#define __Pyx_PyBaseString_Check(obj) PyUnicode_Check(obj)

#define __Pyx_PyBaseString_CheckExact(obj) PyUnicode_CheckExact(obj)

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

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

#ifndef PySet_CheckExact

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

#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)

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

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

#if CYTHON_ASSUME_SAFE_MACROS

#define __Pyx_PySequence_SIZE(seq) Py_SIZE(seq)

#define __Pyx_PySequence_SIZE(seq) PySequence_Size(seq)

#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

#if PY_MAJOR_VERSION >= 3

#define PyBoolObject PyLongObject

#if PY_MAJOR_VERSION >= 3 && CYTHON_COMPILING_IN_PYPY

#ifndef PyUnicode_InternFromString

#define PyUnicode_InternFromString(s) PyUnicode_FromString(s)

#endif

#if PY_VERSION_HEX < 0x030200A4

typedef long Py_hash_t;

#define __Pyx_PyInt_FromHash_t PyInt_FromLong

#define __Pyx_PyInt_AsHash_t __Pyx_PyIndex_AsHash_t

#define __Pyx_PyInt_FromHash_t PyInt_FromSsize_t

#define __Pyx_PyInt_AsHash_t __Pyx_PyIndex_AsSsize_t

#if PY_MAJOR_VERSION >= 3

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

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

#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

#define __Pyx_PyType_AsAsync(obj) NULL

#ifndef __Pyx_PyAsyncMethodsStruct

typedef struct {

unaryfunc am_await;

unaryfunc am_aiter;

unaryfunc am_anext;

} __Pyx_PyAsyncMethodsStruct;

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

#if !defined(_USE_MATH_DEFINES)

#define _USE_MATH_DEFINES

#endif

#include <math.h>

#ifdef NAN

#define __PYX_NAN() ((float) NAN)

static CYTHON_INLINE float __PYX_NAN() {

float value;

memset(&value, 0xFF, sizeof(value));

return value;

}

#if defined(__CYGWIN__) && defined(_LDBL_EQ_DBL)

#define __Pyx_truncl trunc

#define __Pyx_truncl truncl

#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

#define __PYX_HAVE__ssh__connector

#define __PYX_HAVE_API__ssh__connector

#include <stddef.h>

#include <time.h>

#include <sys/types.h>

#include "libssh/libssh.h"

#include <string.h>

#include <stdio.h>

#include "pythread.h"

#ifdef _OPENMP

#include <omp.h>

#endif /* _OPENMP */

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

#define CYTHON_WITHOUT_ASSERTIONS

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)

#define __Pyx_sst_abs(value) ((value<0) ? -value : value)

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

#define __Pyx_PyStr_FromString __Pyx_PyUnicode_FromString

#define __Pyx_PyStr_FromStringAndSize __Pyx_PyUnicode_FromStringAndSize

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

static CYTHON_INLINE size_t __Pyx_Py_UNICODE_strlen(const Py_UNICODE *u) {

const Py_UNICODE *u_end = u;

while (*u_end++) ;

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

}

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

#define __Pyx_PyUnicode_FromUnicodeAndLength PyUnicode_FromUnicode

#define __Pyx_PyUnicode_AsUnicode PyUnicode_AsUnicode

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

#define __Pyx_Owned_Py_None(b) __Pyx_NewRef(Py_None)

static CYTHON_INLINE PyObject * __Pyx_PyBool_FromLong(long b);

static CYTHON_INLINE int __Pyx_PyObject_IsTrue(PyObject*);

static CYTHON_INLINE int __Pyx_PyObject_IsTrueAndDecref(PyObject*);

static CYTHON_INLINE PyObject* __Pyx_PyNumber_IntOrLong(PyObject* x);

#define __Pyx_PySequence_Tuple(obj)\

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

static CYTHON_INLINE Py_ssize_t __Pyx_PyIndex_AsSsize_t(PyObject*);

static CYTHON_INLINE PyObject * __Pyx_PyInt_FromSize_t(size_t);

static CYTHON_INLINE Py_hash_t __Pyx_PyIndex_AsHash_t(PyObject*);

#if CYTHON_ASSUME_SAFE_MACROS

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

#define __pyx_PyFloat_AsDouble(x) PyFloat_AsDouble(x)

#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))

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

#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;

}

#if __PYX_DEFAULT_STRING_ENCODING_IS_DEFAULT && PY_MAJOR_VERSION >= 3

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

#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;

}

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

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

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

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

#define likely(x) (x)

#define unlikely(x) (x)

#endif /* __GNUC__ */

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

static PyObject *__pyx_m = NULL;

static PyObject *__pyx_d;

static PyObject *__pyx_b;

static PyObject *__pyx_cython_runtime = NULL;

static PyObject *__pyx_empty_tuple;

static PyObject *__pyx_empty_bytes;

static PyObject *__pyx_empty_unicode;

static int __pyx_lineno;

static int __pyx_clineno = 0;

static const char * __pyx_cfilenm= __FILE__;

static const char *__pyx_filename;

static const char *__pyx_f[] = {

"stringsource",

"ssh/connector.pyx",

"ssh/session.pxd",

"env/lib/python3.9/site-packages/Cython/Includes/cpython/type.pxd",

"env/lib/python3.9/site-packages/Cython/Includes/cpython/bool.pxd",

"env/lib/python3.9/site-packages/Cython/Includes/cpython/complex.pxd",

"ssh/channel.pxd",

};

#define __Pyx_PyGILState_Ensure PyGILState_Ensure

#define __Pyx_PyGILState_Release PyGILState_Release

#define __Pyx_FastGIL_Remember()

#define __Pyx_FastGIL_Forget()

#define __Pyx_FastGilFuncInit()

#ifndef __PYX_FORCE_INIT_THREADS

#define __PYX_FORCE_INIT_THREADS 0

struct __pyx_obj_3ssh_7session_Session;

struct __pyx_obj_3ssh_7channel_Channel;

struct __pyx_obj_3ssh_9connector_Flag;

struct __pyx_obj_3ssh_9connector_Connector;

struct __pyx_obj_3ssh_7session_Session {

};