#ifndef Py_OBJECT_H

#define Py_OBJECT_H

#ifdef __cplusplus

extern "C" {

#include "pystats.h"

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

# define Py_REF_DEBUG

#if defined(Py_LIMITED_API) && defined(Py_TRACE_REFS)

# error Py_LIMITED_API is incompatible with Py_TRACE_REFS

#ifdef Py_TRACE_REFS

#define _PyObject_HEAD_EXTRA \

PyObject *_ob_next; \

PyObject *_ob_prev;

#define _PyObject_EXTRA_INIT _Py_NULL, _Py_NULL,

# 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 _PyObject_HEAD_IMMORTAL_INIT(type) \

{ _PyObject_EXTRA_INIT \

999999999, (type) },

#define _PyVarObject_HEAD_IMMORTAL_INIT(type, size) \

{ _PyObject_HEAD_IMMORTAL_INIT(type) (size) },

#define PyObject_VAR_HEAD PyVarObject ob_base;

#define Py_INVALID_SIZE (Py_ssize_t)-1

struct _object {

};

#define _PyObject_CAST(op) _Py_CAST(PyObject*, (op))

typedef struct {

PyObject ob_base;

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

} PyVarObject;

#define _PyVarObject_CAST(op) _Py_CAST(PyVarObject*, (op))

PyAPI_FUNC(int) Py_Is(PyObject *x, PyObject *y);

#define Py_Is(x, y) ((x) == (y))

static inline Py_ssize_t Py_REFCNT(PyObject *ob) {

return ob->ob_refcnt;

}

#if !defined(Py_LIMITED_API) || Py_LIMITED_API+0 < 0x030b0000

# define Py_REFCNT(ob) Py_REFCNT(_PyObject_CAST(ob))

static inline PyTypeObject* Py_TYPE(PyObject *ob) {

return ob->ob_type;

}

#if !defined(Py_LIMITED_API) || Py_LIMITED_API+0 < 0x030b0000

# define Py_TYPE(ob) Py_TYPE(_PyObject_CAST(ob))

PyAPI_DATA(PyTypeObject) PyLong_Type;

PyAPI_DATA(PyTypeObject) PyBool_Type;

static inline Py_ssize_t Py_SIZE(PyObject *ob) {

assert(ob->ob_type != &PyLong_Type);

assert(ob->ob_type != &PyBool_Type);

PyVarObject *var_ob = _PyVarObject_CAST(ob);

return var_ob->ob_size;

}

#if !defined(Py_LIMITED_API) || Py_LIMITED_API+0 < 0x030b0000

# define Py_SIZE(ob) Py_SIZE(_PyObject_CAST(ob))

static inline int Py_IS_TYPE(PyObject *ob, PyTypeObject *type) {

return Py_TYPE(ob) == type;

}

#if !defined(Py_LIMITED_API) || Py_LIMITED_API+0 < 0x030b0000

# define Py_IS_TYPE(ob, type) Py_IS_TYPE(_PyObject_CAST(ob), (type))

static inline void Py_SET_REFCNT(PyObject *ob, Py_ssize_t refcnt) {

ob->ob_refcnt = refcnt;

}

#if !defined(Py_LIMITED_API) || Py_LIMITED_API+0 < 0x030b0000

# define Py_SET_REFCNT(ob, refcnt) Py_SET_REFCNT(_PyObject_CAST(ob), (refcnt))

static inline void Py_SET_TYPE(PyObject *ob, PyTypeObject *type) {

ob->ob_type = type;

}

#if !defined(Py_LIMITED_API) || Py_LIMITED_API+0 < 0x030b0000

# define Py_SET_TYPE(ob, type) Py_SET_TYPE(_PyObject_CAST(ob), type)

static inline void Py_SET_SIZE(PyVarObject *ob, Py_ssize_t size) {

assert(ob->ob_base.ob_type != &PyLong_Type);

assert(ob->ob_base.ob_type != &PyBool_Type);

ob->ob_size = size;

}

#if !defined(Py_LIMITED_API) || Py_LIMITED_API+0 < 0x030b0000

# define Py_SET_SIZE(ob, size) Py_SET_SIZE(_PyVarObject_CAST(ob), (size))

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

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

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

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

typedef void (*freefunc)(void *);

typedef void (*destructor)(PyObject *);

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)(PyTypeObject *, PyObject *, PyObject *);

typedef PyObject *(*allocfunc)(PyTypeObject *, Py_ssize_t);

#if !defined(Py_LIMITED_API) || Py_LIMITED_API+0 >= 0x030c0000 // 3.12

typedef PyObject *(*vectorcallfunc)(PyObject *callable, PyObject *const *args,

size_t nargsf, PyObject *kwnames);

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

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

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

PyAPI_FUNC(PyObject *) PyType_GetModule(PyTypeObject *);

PyAPI_FUNC(void *) PyType_GetModuleState(PyTypeObject *);

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

PyAPI_FUNC(PyObject *) PyType_GetName(PyTypeObject *);

PyAPI_FUNC(PyObject *) PyType_GetQualName(PyTypeObject *);

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

PyAPI_FUNC(PyObject *) PyType_FromMetaclass(PyTypeObject*, PyObject*, PyType_Spec*, PyObject*);

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

static inline int PyObject_TypeCheck(PyObject *ob, PyTypeObject *type) {

return Py_IS_TYPE(ob, type) || PyType_IsSubtype(Py_TYPE(ob), type);

}

#if !defined(Py_LIMITED_API) || Py_LIMITED_API+0 < 0x030b0000

# define PyObject_TypeCheck(ob, type) PyObject_TypeCheck(_PyObject_CAST(ob), (type))

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

PyAPI_FUNC(int) PyType_Ready(PyTypeObject *);

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

PyAPI_FUNC(PyObject *) PyType_GenericNew(PyTypeObject *,

PyObject *, PyObject *);

PyAPI_FUNC(unsigned int) PyType_ClearCache(void);

PyAPI_FUNC(void) PyType_Modified(PyTypeObject *);

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

PyAPI_FUNC(PyObject *) PyObject_SelfIter(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 *);

PyAPI_FUNC(PyObject *) PyObject_Dir(PyObject *);

#ifndef Py_LIMITED_API

PyAPI_FUNC(PyObject *) _PyObject_GetState(PyObject *);

PyAPI_FUNC(int) Py_ReprEnter(PyObject *);

PyAPI_FUNC(void) Py_ReprLeave(PyObject *);

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

#ifndef Py_LIMITED_API

#define _Py_TPFLAGS_STATIC_BUILTIN (1 << 1)

#define Py_TPFLAGS_MANAGED_WEAKREF (1 << 3)

#define Py_TPFLAGS_MANAGED_DICT (1 << 4)

#define Py_TPFLAGS_PREHEADER (Py_TPFLAGS_MANAGED_WEAKREF | Py_TPFLAGS_MANAGED_DICT)

#define Py_TPFLAGS_SEQUENCE (1 << 5)

#define Py_TPFLAGS_MAPPING (1 << 6)

#define Py_TPFLAGS_DISALLOW_INSTANTIATION (1UL << 7)

#define Py_TPFLAGS_IMMUTABLETYPE (1UL << 8)

#define Py_TPFLAGS_HEAPTYPE (1UL << 9)

#define Py_TPFLAGS_BASETYPE (1UL << 10)

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

#define Py_TPFLAGS_HAVE_VECTORCALL (1UL << 11)

#ifndef Py_LIMITED_API

#define _Py_TPFLAGS_HAVE_VECTORCALL Py_TPFLAGS_HAVE_VECTORCALL

#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_METHOD_DESCRIPTOR (1UL << 17)

#define Py_TPFLAGS_VALID_VERSION_TAG (1UL << 19)

#define Py_TPFLAGS_IS_ABSTRACT (1UL << 20)

#define _Py_TPFLAGS_MATCH_SELF (1UL << 22)

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

Py_TPFLAGS_HAVE_STACKLESS_EXTENSION | \

0)

#define Py_TPFLAGS_HAVE_FINALIZE (1UL << 0)

#define Py_TPFLAGS_HAVE_VERSION_TAG (1UL << 18)

#ifdef Py_REF_DEBUG

# if defined(Py_LIMITED_API) && Py_LIMITED_API+0 < 0x030A0000

extern Py_ssize_t _Py_RefTotal;

# define _Py_INC_REFTOTAL() _Py_RefTotal++

# define _Py_DEC_REFTOTAL() _Py_RefTotal--

# elif !defined(Py_LIMITED_API) || Py_LIMITED_API+0 > 0x030C0000

PyAPI_FUNC(void) _Py_IncRefTotal_DO_NOT_USE_THIS(void);

PyAPI_FUNC(void) _Py_DecRefTotal_DO_NOT_USE_THIS(void);

# define _Py_INC_REFTOTAL() _Py_IncRefTotal_DO_NOT_USE_THIS()

# define _Py_DEC_REFTOTAL() _Py_DecRefTotal_DO_NOT_USE_THIS()

PyAPI_FUNC(void) _Py_NegativeRefcount(const char *filename, int lineno,

PyObject *op);

#endif /* Py_REF_DEBUG */

PyAPI_FUNC(void) _Py_Dealloc(PyObject *);

PyAPI_FUNC(void) Py_IncRef(PyObject *);

PyAPI_FUNC(void) Py_DecRef(PyObject *);

PyAPI_FUNC(void) _Py_IncRef(PyObject *);

PyAPI_FUNC(void) _Py_DecRef(PyObject *);

static inline void Py_INCREF(PyObject *op)

{

#if defined(Py_REF_DEBUG) && defined(Py_LIMITED_API) && Py_LIMITED_API+0 >= 0x030A0000

// Stable ABI for Python 3.10 built in debug mode.

_Py_IncRef(op);

_Py_INCREF_STAT_INC();

// Non-limited C API and limited C API for Python 3.9 and older access

// directly PyObject.ob_refcnt.

#ifdef Py_REF_DEBUG

_Py_INC_REFTOTAL();

#endif // Py_REF_DEBUG

op->ob_refcnt++;

}

#if !defined(Py_LIMITED_API) || Py_LIMITED_API+0 < 0x030b0000

# define Py_INCREF(op) Py_INCREF(_PyObject_CAST(op))

#if defined(Py_REF_DEBUG) && defined(Py_LIMITED_API) && Py_LIMITED_API+0 >= 0x030A0000

static inline void Py_DECREF(PyObject *op) {

_Py_DecRef(op);

}

#define Py_DECREF(op) Py_DECREF(_PyObject_CAST(op))

#elif defined(Py_REF_DEBUG)

static inline void Py_DECREF(const char *filename, int lineno, PyObject *op)

{

_Py_DECREF_STAT_INC();

_Py_DEC_REFTOTAL();

if (--op->ob_refcnt != 0) {

if (op->ob_refcnt < 0) {

_Py_NegativeRefcount(filename, lineno, op);

}

}

else {

_Py_Dealloc(op);

}

}

#define Py_DECREF(op) Py_DECREF(__FILE__, __LINE__, _PyObject_CAST(op))

static inline void Py_DECREF(PyObject *op)

{

_Py_DECREF_STAT_INC();

// Non-limited C API and limited C API for Python 3.9 and older access

// directly PyObject.ob_refcnt.

if (--op->ob_refcnt == 0) {

_Py_Dealloc(op);

}

}

#define Py_DECREF(op) Py_DECREF(_PyObject_CAST(op))

#undef _Py_INC_REFTOTAL

#undef _Py_DEC_REFTOTAL

#ifdef _Py_TYPEOF

#define Py_CLEAR(op) \

do { \

_Py_TYPEOF(op)* _tmp_op_ptr = &(op); \

_Py_TYPEOF(op) _tmp_old_op = (*_tmp_op_ptr); \

if (_tmp_old_op != NULL) { \

*_tmp_op_ptr = _Py_NULL; \

Py_DECREF(_tmp_old_op); \

} \

} while (0)

#define Py_CLEAR(op) \

do { \

PyObject **_tmp_op_ptr = _Py_CAST(PyObject**, &(op)); \

PyObject *_tmp_old_op = (*_tmp_op_ptr); \

if (_tmp_old_op != NULL) { \

PyObject *_null_ptr = _Py_NULL; \

memcpy(_tmp_op_ptr, &_null_ptr, sizeof(PyObject*)); \

Py_DECREF(_tmp_old_op); \

} \

} while (0)

static inline void Py_XINCREF(PyObject *op)

{

if (op != _Py_NULL) {

Py_INCREF(op);

}

}

#if !defined(Py_LIMITED_API) || Py_LIMITED_API+0 < 0x030b0000

# define Py_XINCREF(op) Py_XINCREF(_PyObject_CAST(op))

static inline void Py_XDECREF(PyObject *op)

{

if (op != _Py_NULL) {

Py_DECREF(op);

}

}

#if !defined(Py_LIMITED_API) || Py_LIMITED_API+0 < 0x030b0000

# define Py_XDECREF(op) Py_XDECREF(_PyObject_CAST(op))

PyAPI_FUNC(PyObject*) Py_NewRef(PyObject *obj);

PyAPI_FUNC(PyObject*) Py_XNewRef(PyObject *obj);

static inline PyObject* _Py_NewRef(PyObject *obj)

{

Py_INCREF(obj);

return obj;

}

static inline PyObject* _Py_XNewRef(PyObject *obj)

{

Py_XINCREF(obj);

return obj;

}

#if !defined(Py_LIMITED_API) || Py_LIMITED_API+0 < 0x030b0000

# define Py_NewRef(obj) _Py_NewRef(_PyObject_CAST(obj))

# define Py_XNewRef(obj) _Py_XNewRef(_PyObject_CAST(obj))

# define Py_NewRef(obj) _Py_NewRef(obj)

# define Py_XNewRef(obj) _Py_XNewRef(obj)

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

#define Py_None (&_Py_NoneStruct)

PyAPI_FUNC(int) Py_IsNone(PyObject *x);

#define Py_IsNone(x) Py_Is((x), Py_None)

#define Py_RETURN_NONE return Py_NewRef(Py_None)

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

#define Py_NotImplemented (&_Py_NotImplementedStruct)

#define Py_RETURN_NOTIMPLEMENTED return Py_NewRef(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

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

typedef enum {

PYGEN_RETURN = 0,

PYGEN_ERROR = -1,

PYGEN_NEXT = 1,

} PySendResult;

#define Py_RETURN_RICHCOMPARE(val1, val2, op) \

do { \

switch (op) { \

case Py_EQ: if ((val1) == (val2)) Py_RETURN_TRUE; Py_RETURN_FALSE; \

case Py_NE: if ((val1) != (val2)) Py_RETURN_TRUE; Py_RETURN_FALSE; \

case Py_LT: if ((val1) < (val2)) Py_RETURN_TRUE; Py_RETURN_FALSE; \

case Py_GT: if ((val1) > (val2)) Py_RETURN_TRUE; Py_RETURN_FALSE; \

case Py_LE: if ((val1) <= (val2)) Py_RETURN_TRUE; Py_RETURN_FALSE; \

case Py_GE: if ((val1) >= (val2)) Py_RETURN_TRUE; Py_RETURN_FALSE; \

default: \

Py_UNREACHABLE(); \

} \

} while (0)

#ifndef Py_LIMITED_API

# define Py_CPYTHON_OBJECT_H

# include "cpython/object.h"

# undef Py_CPYTHON_OBJECT_H

static inline int

PyType_HasFeature(PyTypeObject *type, unsigned long feature)

{

unsigned long flags;

#ifdef Py_LIMITED_API

// PyTypeObject is opaque in the limited C API

flags = PyType_GetFlags(type);

flags = type->tp_flags;

return ((flags & feature) != 0);

}

#define PyType_FastSubclass(type, flag) PyType_HasFeature((type), (flag))

static inline int PyType_Check(PyObject *op) {

return PyType_FastSubclass(Py_TYPE(op), Py_TPFLAGS_TYPE_SUBCLASS);

}

#if !defined(Py_LIMITED_API) || Py_LIMITED_API+0 < 0x030b0000

# define PyType_Check(op) PyType_Check(_PyObject_CAST(op))

#define _PyType_CAST(op) \

(assert(PyType_Check(op)), _Py_CAST(PyTypeObject*, (op)))

static inline int PyType_CheckExact(PyObject *op) {

return Py_IS_TYPE(op, &PyType_Type);

}

#if !defined(Py_LIMITED_API) || Py_LIMITED_API+0 < 0x030b0000

# define PyType_CheckExact(op) PyType_CheckExact(_PyObject_CAST(op))

#ifdef __cplusplus

}

#endif // !Py_OBJECT_H