#ifndef Py_OBJECT_H

#define Py_OBJECT_H

#ifdef __cplusplus

extern "C" {

#if defined(Py_DEBUG) && !defined(Py_TRACE_REFS)

#define Py_TRACE_REFS

#if defined(Py_TRACE_REFS) && !defined(Py_REF_DEBUG)

#define Py_REF_DEBUG

#if defined(Py_LIMITED_API) && defined(Py_REF_DEBUG)

#error Py_LIMITED_API is incompatible with Py_DEBUG, Py_TRACE_REFS, and Py_REF_DEBUG

#ifdef Py_TRACE_REFS

#define _PyObject_HEAD_EXTRA \

struct _object *_ob_next; \

struct _object *_ob_prev;

#define _PyObject_EXTRA_INIT 0, 0,

#define _PyObject_HEAD_EXTRA

#define _PyObject_EXTRA_INIT

#define PyObject_HEAD PyObject ob_base;

#define PyObject_HEAD_INIT(type) \

{ _PyObject_EXTRA_INIT \

1, type },

#define PyVarObject_HEAD_INIT(type, size) \

{ PyObject_HEAD_INIT(type) size },

#define PyObject_VAR_HEAD PyVarObject ob_base;

#define Py_INVALID_SIZE (Py_ssize_t)-1

typedef struct _object {

} PyObject;

typedef struct {

PyObject ob_base;

Py_ssize_t ob_size; /* Number of items in variable part */

} PyVarObject;

#define Py_REFCNT(ob) (((PyObject*)(ob))->ob_refcnt)

#define Py_TYPE(ob) (((PyObject*)(ob))->ob_type)

#define Py_SIZE(ob) (((PyVarObject*)(ob))->ob_size)

#ifndef Py_LIMITED_API

typedef struct _Py_Identifier {

} _Py_Identifier;

#define _Py_static_string_init(value) { .next = NULL, .string = value, .object = NULL }

#define _Py_static_string(varname, value) static _Py_Identifier varname = _Py_static_string_init(value)

#define _Py_IDENTIFIER(varname) _Py_static_string(PyId_##varname, #varname)

#endif /* !Py_LIMITED_API */

typedef PyObject * (*unaryfunc)(PyObject *);

typedef PyObject * (*binaryfunc)(PyObject *, PyObject *);

typedef PyObject * (*ternaryfunc)(PyObject *, PyObject *, PyObject *);

typedef int (*inquiry)(PyObject *);

typedef Py_ssize_t (*lenfunc)(PyObject *);

typedef PyObject *(*ssizeargfunc)(PyObject *, Py_ssize_t);

typedef PyObject *(*ssizessizeargfunc)(PyObject *, Py_ssize_t, Py_ssize_t);

typedef int(*ssizeobjargproc)(PyObject *, Py_ssize_t, PyObject *);

typedef int(*ssizessizeobjargproc)(PyObject *, Py_ssize_t, Py_ssize_t, PyObject *);

typedef int(*objobjargproc)(PyObject *, PyObject *, PyObject *);

#ifndef Py_LIMITED_API

typedef struct bufferinfo {

} Py_buffer;

typedef int (*getbufferproc)(PyObject *, Py_buffer *, int);

typedef void (*releasebufferproc)(PyObject *, Py_buffer *);

#define PyBUF_MAX_NDIM 64

#define PyBUF_SIMPLE 0

#define PyBUF_WRITABLE 0x0001

#define PyBUF_WRITEABLE PyBUF_WRITABLE

#define PyBUF_FORMAT 0x0004

#define PyBUF_ND 0x0008

#define PyBUF_STRIDES (0x0010 | PyBUF_ND)

#define PyBUF_C_CONTIGUOUS (0x0020 | PyBUF_STRIDES)

#define PyBUF_F_CONTIGUOUS (0x0040 | PyBUF_STRIDES)

#define PyBUF_ANY_CONTIGUOUS (0x0080 | PyBUF_STRIDES)

#define PyBUF_INDIRECT (0x0100 | PyBUF_STRIDES)

#define PyBUF_CONTIG (PyBUF_ND | PyBUF_WRITABLE)

#define PyBUF_CONTIG_RO (PyBUF_ND)

#define PyBUF_STRIDED (PyBUF_STRIDES | PyBUF_WRITABLE)

#define PyBUF_STRIDED_RO (PyBUF_STRIDES)

#define PyBUF_RECORDS (PyBUF_STRIDES | PyBUF_WRITABLE | PyBUF_FORMAT)

#define PyBUF_RECORDS_RO (PyBUF_STRIDES | PyBUF_FORMAT)

#define PyBUF_FULL (PyBUF_INDIRECT | PyBUF_WRITABLE | PyBUF_FORMAT)

#define PyBUF_FULL_RO (PyBUF_INDIRECT | PyBUF_FORMAT)

#define PyBUF_READ 0x100

#define PyBUF_WRITE 0x200

#endif /* Py_LIMITED_API */

typedef int (*objobjproc)(PyObject *, PyObject *);

typedef int (*visitproc)(PyObject *, void *);

typedef int (*traverseproc)(PyObject *, visitproc, void *);

#ifndef Py_LIMITED_API

typedef struct {

/* Number implementations must check *both*

binaryfunc nb_add;

binaryfunc nb_subtract;

binaryfunc nb_multiply;

binaryfunc nb_remainder;

binaryfunc nb_divmod;

ternaryfunc nb_power;

unaryfunc nb_negative;

unaryfunc nb_positive;

unaryfunc nb_absolute;

inquiry nb_bool;

unaryfunc nb_invert;

binaryfunc nb_lshift;

binaryfunc nb_rshift;

binaryfunc nb_and;

binaryfunc nb_xor;

binaryfunc nb_or;

unaryfunc nb_int;

void *nb_reserved; /* the slot formerly known as nb_long */

unaryfunc nb_float;

binaryfunc nb_inplace_add;

binaryfunc nb_inplace_subtract;

binaryfunc nb_inplace_multiply;

binaryfunc nb_inplace_remainder;

ternaryfunc nb_inplace_power;

binaryfunc nb_inplace_lshift;

binaryfunc nb_inplace_rshift;

binaryfunc nb_inplace_and;

binaryfunc nb_inplace_xor;

binaryfunc nb_inplace_or;

binaryfunc nb_floor_divide;

binaryfunc nb_true_divide;

binaryfunc nb_inplace_floor_divide;

binaryfunc nb_inplace_true_divide;

unaryfunc nb_index;

binaryfunc nb_matrix_multiply;

binaryfunc nb_inplace_matrix_multiply;

} PyNumberMethods;

typedef struct {

lenfunc sq_length;

binaryfunc sq_concat;

ssizeargfunc sq_repeat;

ssizeargfunc sq_item;

void *was_sq_slice;

ssizeobjargproc sq_ass_item;

void *was_sq_ass_slice;

objobjproc sq_contains;

binaryfunc sq_inplace_concat;

ssizeargfunc sq_inplace_repeat;

} PySequenceMethods;

typedef struct {

lenfunc mp_length;

binaryfunc mp_subscript;

objobjargproc mp_ass_subscript;

} PyMappingMethods;

typedef struct {

unaryfunc am_await;

unaryfunc am_aiter;

unaryfunc am_anext;

} PyAsyncMethods;

typedef struct {

getbufferproc bf_getbuffer;

releasebufferproc bf_releasebuffer;

} PyBufferProcs;

#endif /* Py_LIMITED_API */

typedef void (*freefunc)(void *);

typedef void (*destructor)(PyObject *);

#ifndef Py_LIMITED_API

typedef int (*printfunc)(PyObject *, FILE *, int);

typedef PyObject *(*getattrfunc)(PyObject *, char *);

typedef PyObject *(*getattrofunc)(PyObject *, PyObject *);

typedef int (*setattrfunc)(PyObject *, char *, PyObject *);

typedef int (*setattrofunc)(PyObject *, PyObject *, PyObject *);

typedef PyObject *(*reprfunc)(PyObject *);

typedef Py_hash_t (*hashfunc)(PyObject *);

typedef PyObject *(*richcmpfunc) (PyObject *, PyObject *, int);

typedef PyObject *(*getiterfunc) (PyObject *);

typedef PyObject *(*iternextfunc) (PyObject *);

typedef PyObject *(*descrgetfunc) (PyObject *, PyObject *, PyObject *);

typedef int (*descrsetfunc) (PyObject *, PyObject *, PyObject *);

typedef int (*initproc)(PyObject *, PyObject *, PyObject *);

typedef PyObject *(*newfunc)(struct _typeobject *, PyObject *, PyObject *);

typedef PyObject *(*allocfunc)(struct _typeobject *, Py_ssize_t);

#ifdef Py_LIMITED_API

typedef struct _typeobject PyTypeObject; /* opaque */

typedef struct _typeobject {

} PyTypeObject;

typedef struct{

int slot; /* slot id, see below */

void *pfunc; /* function pointer */

} PyType_Slot;

typedef struct{

const char* name;

int basicsize;

int itemsize;

unsigned int flags;

PyType_Slot *slots; /* terminated by slot==0. */

} PyType_Spec;

PyAPI_FUNC(PyObject*) PyType_FromSpec(PyType_Spec*);

#if !defined(Py_LIMITED_API) || Py_LIMITED_API+0 >= 0x03030000

PyAPI_FUNC(PyObject*) PyType_FromSpecWithBases(PyType_Spec*, PyObject*);

#if !defined(Py_LIMITED_API) || Py_LIMITED_API+0 >= 0x03040000

PyAPI_FUNC(void*) PyType_GetSlot(PyTypeObject*, int);

#ifndef Py_LIMITED_API

typedef struct _heaptypeobject {

} PyHeapTypeObject;

#define PyHeapType_GET_MEMBERS(etype) \

((PyMemberDef *)(((char *)etype) + Py_TYPE(etype)->tp_basicsize))

PyAPI_FUNC(int) PyType_IsSubtype(PyTypeObject *, PyTypeObject *);

#define PyObject_TypeCheck(ob, tp) \

(Py_TYPE(ob) == (tp) || PyType_IsSubtype(Py_TYPE(ob), (tp)))

PyAPI_DATA(PyTypeObject) PyType_Type; /* built-in 'type' */

PyAPI_DATA(PyTypeObject) PyBaseObject_Type; /* built-in 'object' */

PyAPI_DATA(PyTypeObject) PySuper_Type; /* built-in 'super' */

PyAPI_FUNC(unsigned long) PyType_GetFlags(PyTypeObject*);

#define PyType_Check(op) \

PyType_FastSubclass(Py_TYPE(op), Py_TPFLAGS_TYPE_SUBCLASS)

#define PyType_CheckExact(op) (Py_TYPE(op) == &PyType_Type)

PyAPI_FUNC(int) PyType_Ready(PyTypeObject *);

PyAPI_FUNC(PyObject *) PyType_GenericAlloc(PyTypeObject *, Py_ssize_t);

PyAPI_FUNC(PyObject *) PyType_GenericNew(PyTypeObject *,

PyObject *, PyObject *);

#ifndef Py_LIMITED_API

PyAPI_FUNC(PyObject *) _PyType_Lookup(PyTypeObject *, PyObject *);

PyAPI_FUNC(PyObject *) _PyType_LookupId(PyTypeObject *, _Py_Identifier *);

PyAPI_FUNC(PyObject *) _PyObject_LookupSpecial(PyObject *, _Py_Identifier *);

PyAPI_FUNC(PyTypeObject *) _PyType_CalculateMetaclass(PyTypeObject *, PyObject *);

PyAPI_FUNC(unsigned int) PyType_ClearCache(void);

PyAPI_FUNC(void) PyType_Modified(PyTypeObject *);

#ifndef Py_LIMITED_API

PyAPI_FUNC(PyObject *) _PyType_GetDocFromInternalDoc(const char *, const char *);

PyAPI_FUNC(PyObject *) _PyType_GetTextSignatureFromInternalDoc(const char *, const char *);

#ifndef Py_LIMITED_API

struct _Py_Identifier;

PyAPI_FUNC(int) PyObject_Print(PyObject *, FILE *, int);

PyAPI_FUNC(void) _Py_BreakPoint(void);

PyAPI_FUNC(void) _PyObject_Dump(PyObject *);

PyAPI_FUNC(PyObject *) PyObject_Repr(PyObject *);

PyAPI_FUNC(PyObject *) PyObject_Str(PyObject *);

PyAPI_FUNC(PyObject *) PyObject_ASCII(PyObject *);

PyAPI_FUNC(PyObject *) PyObject_Bytes(PyObject *);

PyAPI_FUNC(PyObject *) PyObject_RichCompare(PyObject *, PyObject *, int);

PyAPI_FUNC(int) PyObject_RichCompareBool(PyObject *, PyObject *, int);

PyAPI_FUNC(PyObject *) PyObject_GetAttrString(PyObject *, const char *);

PyAPI_FUNC(int) PyObject_SetAttrString(PyObject *, const char *, PyObject *);

PyAPI_FUNC(int) PyObject_HasAttrString(PyObject *, const char *);

PyAPI_FUNC(PyObject *) PyObject_GetAttr(PyObject *, PyObject *);

PyAPI_FUNC(int) PyObject_SetAttr(PyObject *, PyObject *, PyObject *);

PyAPI_FUNC(int) PyObject_HasAttr(PyObject *, PyObject *);

#ifndef Py_LIMITED_API

PyAPI_FUNC(int) _PyObject_IsAbstract(PyObject *);

PyAPI_FUNC(PyObject *) _PyObject_GetAttrId(PyObject *, struct _Py_Identifier *);

PyAPI_FUNC(int) _PyObject_SetAttrId(PyObject *, struct _Py_Identifier *, PyObject *);

PyAPI_FUNC(int) _PyObject_HasAttrId(PyObject *, struct _Py_Identifier *);

PyAPI_FUNC(PyObject **) _PyObject_GetDictPtr(PyObject *);

PyAPI_FUNC(PyObject *) PyObject_SelfIter(PyObject *);

#ifndef Py_LIMITED_API

PyAPI_FUNC(PyObject *) _PyObject_NextNotImplemented(PyObject *);

PyAPI_FUNC(PyObject *) PyObject_GenericGetAttr(PyObject *, PyObject *);

PyAPI_FUNC(int) PyObject_GenericSetAttr(PyObject *,

PyObject *, PyObject *);

#if !defined(Py_LIMITED_API) || Py_LIMITED_API+0 >= 0x03030000

PyAPI_FUNC(int) PyObject_GenericSetDict(PyObject *, PyObject *, void *);

PyAPI_FUNC(Py_hash_t) PyObject_Hash(PyObject *);

PyAPI_FUNC(Py_hash_t) PyObject_HashNotImplemented(PyObject *);

PyAPI_FUNC(int) PyObject_IsTrue(PyObject *);

PyAPI_FUNC(int) PyObject_Not(PyObject *);

PyAPI_FUNC(int) PyCallable_Check(PyObject *);

PyAPI_FUNC(void) PyObject_ClearWeakRefs(PyObject *);

#ifndef Py_LIMITED_API

PyAPI_FUNC(void) PyObject_CallFinalizer(PyObject *);

PyAPI_FUNC(int) PyObject_CallFinalizerFromDealloc(PyObject *);

#ifndef Py_LIMITED_API

PyAPI_FUNC(PyObject *)

_PyObject_GenericGetAttrWithDict(PyObject *, PyObject *, PyObject *);

PyAPI_FUNC(int)

_PyObject_GenericSetAttrWithDict(PyObject *, PyObject *,

PyObject *, PyObject *);

#endif /* !Py_LIMITED_API */

#ifndef Py_LIMITED_API

PyAPI_FUNC(PyObject *)

_PyObject_GetBuiltin(const char *name);

PyAPI_FUNC(PyObject *) PyObject_Dir(PyObject *);

PyAPI_FUNC(int) Py_ReprEnter(PyObject *);

PyAPI_FUNC(void) Py_ReprLeave(PyObject *);

#define Py_PRINT_RAW 1 /* No string quotes etc. */

#define Py_TPFLAGS_HEAPTYPE (1UL << 9)

#define Py_TPFLAGS_BASETYPE (1UL << 10)

#define Py_TPFLAGS_READY (1UL << 12)

#define Py_TPFLAGS_READYING (1UL << 13)

#define Py_TPFLAGS_HAVE_GC (1UL << 14)

#ifdef STACKLESS

#define Py_TPFLAGS_HAVE_STACKLESS_EXTENSION (3UL << 15)

#define Py_TPFLAGS_HAVE_STACKLESS_EXTENSION 0

#define Py_TPFLAGS_HAVE_VERSION_TAG (1UL << 18)

#define Py_TPFLAGS_VALID_VERSION_TAG (1UL << 19)

#define Py_TPFLAGS_IS_ABSTRACT (1UL << 20)

#define Py_TPFLAGS_LONG_SUBCLASS (1UL << 24)

#define Py_TPFLAGS_LIST_SUBCLASS (1UL << 25)

#define Py_TPFLAGS_TUPLE_SUBCLASS (1UL << 26)

#define Py_TPFLAGS_BYTES_SUBCLASS (1UL << 27)

#define Py_TPFLAGS_UNICODE_SUBCLASS (1UL << 28)

#define Py_TPFLAGS_DICT_SUBCLASS (1UL << 29)

#define Py_TPFLAGS_BASE_EXC_SUBCLASS (1UL << 30)

#define Py_TPFLAGS_TYPE_SUBCLASS (1UL << 31)

#define Py_TPFLAGS_DEFAULT ( \

#define Py_TPFLAGS_HAVE_FINALIZE (1UL << 0)

#ifdef Py_LIMITED_API

#define PyType_HasFeature(t,f) ((PyType_GetFlags(t) & (f)) != 0)

#define PyType_HasFeature(t,f) (((t)->tp_flags & (f)) != 0)

#define PyType_FastSubclass(t,f) PyType_HasFeature(t,f)

#ifdef Py_REF_DEBUG

PyAPI_DATA(Py_ssize_t) _Py_RefTotal;

PyAPI_FUNC(void) _Py_NegativeRefcount(const char *fname,

int lineno, PyObject *op);

PyAPI_FUNC(Py_ssize_t) _Py_GetRefTotal(void);

#define _Py_INC_REFTOTAL _Py_RefTotal++

#define _Py_DEC_REFTOTAL _Py_RefTotal--

#define _Py_REF_DEBUG_COMMA ,

#define _Py_CHECK_REFCNT(OP) \

{ if (((PyObject*)OP)->ob_refcnt < 0) \

_Py_NegativeRefcount(__FILE__, __LINE__, \

(PyObject *)(OP)); \

}

PyAPI_FUNC(void) _PyDebug_PrintTotalRefs(void);

#define _PY_DEBUG_PRINT_TOTAL_REFS() _PyDebug_PrintTotalRefs()

#define _Py_INC_REFTOTAL

#define _Py_DEC_REFTOTAL

#define _Py_REF_DEBUG_COMMA

#define _Py_CHECK_REFCNT(OP) /* a semicolon */;

#define _PY_DEBUG_PRINT_TOTAL_REFS()

#endif /* Py_REF_DEBUG */

#ifdef COUNT_ALLOCS

PyAPI_FUNC(void) inc_count(PyTypeObject *);

PyAPI_FUNC(void) dec_count(PyTypeObject *);

#define _Py_INC_TPALLOCS(OP) inc_count(Py_TYPE(OP))

#define _Py_INC_TPFREES(OP) dec_count(Py_TYPE(OP))

#define _Py_DEC_TPFREES(OP) Py_TYPE(OP)->tp_frees--

#define _Py_COUNT_ALLOCS_COMMA ,

#define _Py_INC_TPALLOCS(OP)

#define _Py_INC_TPFREES(OP)

#define _Py_DEC_TPFREES(OP)

#define _Py_COUNT_ALLOCS_COMMA

#endif /* COUNT_ALLOCS */

#ifdef Py_TRACE_REFS

PyAPI_FUNC(void) _Py_NewReference(PyObject *);

PyAPI_FUNC(void) _Py_ForgetReference(PyObject *);

PyAPI_FUNC(void) _Py_Dealloc(PyObject *);

PyAPI_FUNC(void) _Py_PrintReferences(FILE *);

PyAPI_FUNC(void) _Py_PrintReferenceAddresses(FILE *);

PyAPI_FUNC(void) _Py_AddToAllObjects(PyObject *, int force);

#define _Py_NewReference(op) ( \

_Py_INC_TPALLOCS(op) _Py_COUNT_ALLOCS_COMMA \

_Py_INC_REFTOTAL _Py_REF_DEBUG_COMMA \

Py_REFCNT(op) = 1)

#define _Py_ForgetReference(op) _Py_INC_TPFREES(op)

#ifdef Py_LIMITED_API

PyAPI_FUNC(void) _Py_Dealloc(PyObject *);

#define _Py_Dealloc(op) ( \

_Py_INC_TPFREES(op) _Py_COUNT_ALLOCS_COMMA \

(*Py_TYPE(op)->tp_dealloc)((PyObject *)(op)))

#endif /* !Py_TRACE_REFS */

#define Py_INCREF(op) ( \

_Py_INC_REFTOTAL _Py_REF_DEBUG_COMMA \

((PyObject *)(op))->ob_refcnt++)

#define Py_DECREF(op) \

do { \

PyObject *_py_decref_tmp = (PyObject *)(op); \

if (_Py_DEC_REFTOTAL _Py_REF_DEBUG_COMMA \

--(_py_decref_tmp)->ob_refcnt != 0) \

_Py_CHECK_REFCNT(_py_decref_tmp) \

else \

_Py_Dealloc(_py_decref_tmp); \

} while (0)

#define Py_CLEAR(op) \

do { \

PyObject *_py_tmp = (PyObject *)(op); \

if (_py_tmp != NULL) { \

(op) = NULL; \

Py_DECREF(_py_tmp); \

} \

} while (0)

#define Py_XINCREF(op) \

do { \

PyObject *_py_xincref_tmp = (PyObject *)(op); \

if (_py_xincref_tmp != NULL) \

Py_INCREF(_py_xincref_tmp); \

} while (0)

#define Py_XDECREF(op) \

do { \

PyObject *_py_xdecref_tmp = (PyObject *)(op); \

if (_py_xdecref_tmp != NULL) \

Py_DECREF(_py_xdecref_tmp); \

} while (0)

#ifndef Py_LIMITED_API

#define Py_SETREF(op, op2) \

do { \

PyObject *_py_tmp = (PyObject *)(op); \

(op) = (op2); \

Py_DECREF(_py_tmp); \

} while (0)

#define Py_XSETREF(op, op2) \

do { \

PyObject *_py_tmp = (PyObject *)(op); \

(op) = (op2); \

Py_XDECREF(_py_tmp); \

} while (0)

#endif /* ifndef Py_LIMITED_API */

PyAPI_FUNC(void) Py_IncRef(PyObject *);

PyAPI_FUNC(void) Py_DecRef(PyObject *);

#ifndef Py_LIMITED_API

PyAPI_DATA(PyTypeObject) _PyNone_Type;

PyAPI_DATA(PyTypeObject) _PyNotImplemented_Type;

#endif /* !Py_LIMITED_API */

PyAPI_DATA(PyObject) _Py_NoneStruct; /* Don't use this directly */

#define Py_None (&_Py_NoneStruct)

#define Py_RETURN_NONE return Py_INCREF(Py_None), Py_None

PyAPI_DATA(PyObject) _Py_NotImplementedStruct; /* Don't use this directly */

#define Py_NotImplemented (&_Py_NotImplementedStruct)

#define Py_RETURN_NOTIMPLEMENTED \

return Py_INCREF(Py_NotImplemented), Py_NotImplemented

#define Py_LT 0

#define Py_LE 1

#define Py_EQ 2

#define Py_NE 3

#define Py_GT 4

#define Py_GE 5

#ifndef Py_LIMITED_API

PyAPI_DATA(int) _Py_SwappedOp[];

#endif /* !Py_LIMITED_API */