#ifndef Py_OBJECT_H

#define Py_OBJECT_H

#ifdef __cplusplus

extern "C" {

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

# define Py_REF_DEBUG

#define PyObject_HEAD PyObject ob_base;

#define _PyObject_EXTRA_INIT

#if defined(Py_GIL_DISABLED)

#define PyObject_HEAD_INIT(type) \

{ \

0, \

0, \

{ 0 }, \

0, \

_Py_IMMORTAL_REFCNT_LOCAL, \

0, \

(type), \

},

#define PyObject_HEAD_INIT(type) \

{ \

{ _Py_IMMORTAL_REFCNT }, \

(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

#ifndef Py_GIL_DISABLED

struct _object {

};

#define _Py_UNOWNED_TID 0

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

#if defined(Py_GIL_DISABLED) && !defined(Py_LIMITED_API)

PyAPI_FUNC(uintptr_t) _Py_GetThreadLocal_Addr(void);

static inline uintptr_t

_Py_ThreadId(void)

{

uintptr_t tid;

#if defined(_MSC_VER) && defined(_M_X64)

tid = __readgsqword(48);

#elif defined(_MSC_VER) && defined(_M_IX86)

tid = __readfsdword(24);

#elif defined(_MSC_VER) && defined(_M_ARM64)

tid = __getReg(18);

#elif defined(__i386__)

__asm__("movl %%gs:0, %0" : "=r" (tid)); // 32-bit always uses GS

#elif defined(__MACH__) && defined(__x86_64__)

__asm__("movq %%gs:0, %0" : "=r" (tid)); // x86_64 macOSX uses GS

#elif defined(__x86_64__)

__asm__("movq %%fs:0, %0" : "=r" (tid)); // x86_64 Linux, BSD uses FS

#elif defined(__arm__)

__asm__ ("mrc p15, 0, %0, c13, c0, 3\nbic %0, %0, #3" : "=r" (tid));

#elif defined(__aarch64__) && defined(__APPLE__)

__asm__ ("mrs %0, tpidrro_el0" : "=r" (tid));

#elif defined(__aarch64__)

__asm__ ("mrs %0, tpidr_el0" : "=r" (tid));

#elif defined(__powerpc64__)

#if defined(__clang__) && _Py__has_builtin(__builtin_thread_pointer)

tid = (uintptr_t)__builtin_thread_pointer();

#else

// r13 is reserved for use as system thread ID by the Power 64-bit ABI.

register uintptr_t tp __asm__ ("r13");

__asm__("" : "=r" (tp));

tid = tp;

#endif

#elif defined(__powerpc__)

#if defined(__clang__) && _Py__has_builtin(__builtin_thread_pointer)

tid = (uintptr_t)__builtin_thread_pointer();

#else

// r2 is reserved for use as system thread ID by the Power 32-bit ABI.

register uintptr_t tp __asm__ ("r2");

__asm__ ("" : "=r" (tp));

tid = tp;

#endif

#elif defined(__s390__) && defined(__GNUC__)

// Both GCC and Clang have supported __builtin_thread_pointer

// for s390 from long time ago.

tid = (uintptr_t)__builtin_thread_pointer();

#elif defined(__riscv)

#if defined(__clang__) && _Py__has_builtin(__builtin_thread_pointer)

tid = (uintptr_t)__builtin_thread_pointer();

#else

// tp is Thread Pointer provided by the RISC-V ABI.

__asm__ ("mv %0, tp" : "=r" (tid));

#endif

// Fallback to a portable implementation if we do not have a faster

// platform-specific implementation.

tid = _Py_GetThreadLocal_Addr();

return tid;

}

static inline Py_ALWAYS_INLINE int

_Py_IsOwnedByCurrentThread(PyObject *ob)

{

#ifdef _Py_THREAD_SANITIZER

return _Py_atomic_load_uintptr_relaxed(&ob->ob_tid) == _Py_ThreadId();

return ob->ob_tid == _Py_ThreadId();

}

PyAPI_FUNC(PyTypeObject*) Py_TYPE(PyObject *ob);

#if defined(Py_LIMITED_API) && Py_LIMITED_API+0 >= 0x030e0000

// Stable ABI implements Py_TYPE() as a function call

// on limited C API version 3.14 and newer.

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

#else

# define Py_TYPE(ob) _Py_TYPE(ob)

#endif

PyAPI_DATA(PyTypeObject) PyLong_Type;

PyAPI_DATA(PyTypeObject) PyBool_Type;

static inline Py_ssize_t Py_SIZE(PyObject *ob) {

assert(Py_TYPE(ob) != &PyLong_Type);

assert(Py_TYPE(ob) != &PyBool_Type);

return _PyVarObject_CAST(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_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(Py_TYPE(_PyObject_CAST(ob)) != &PyLong_Type);

assert(Py_TYPE(_PyObject_CAST(ob)) != &PyBool_Type);

#ifdef Py_GIL_DISABLED

_Py_atomic_store_ssize_relaxed(&ob->ob_size, size);

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 >= 0x030D0000

PyAPI_FUNC(PyObject *) PyType_GetFullyQualifiedName(PyTypeObject *type);

PyAPI_FUNC(PyObject *) PyType_GetModuleName(PyTypeObject *type);

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

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

PyAPI_FUNC(void *) PyObject_GetTypeData(PyObject *obj, PyTypeObject *cls);

PyAPI_FUNC(Py_ssize_t) PyType_GetTypeDataSize(PyTypeObject *cls);

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

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

#define Py_TP_USE_SPEC NULL

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_DelAttrString(PyObject *v, const char *name);

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

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

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

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

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

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

PyAPI_FUNC(int) PyObject_DelAttr(PyObject *v, PyObject *name);

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

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

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

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

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

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_INLINE_VALUES (1 << 2)

#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_ITEMS_AT_END (1UL << 23)

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

#define Py_CONSTANT_NONE 0

#define Py_CONSTANT_FALSE 1

#define Py_CONSTANT_TRUE 2

#define Py_CONSTANT_ELLIPSIS 3

#define Py_CONSTANT_NOT_IMPLEMENTED 4

#define Py_CONSTANT_ZERO 5

#define Py_CONSTANT_ONE 6

#define Py_CONSTANT_EMPTY_STR 7

#define Py_CONSTANT_EMPTY_BYTES 8

#define Py_CONSTANT_EMPTY_TUPLE 9

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

PyAPI_FUNC(PyObject*) Py_GetConstant(unsigned int constant_id);

PyAPI_FUNC(PyObject*) Py_GetConstantBorrowed(unsigned int constant_id);

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

#if defined(Py_LIMITED_API) && Py_LIMITED_API+0 >= 0x030D0000

# define Py_None Py_GetConstantBorrowed(Py_CONSTANT_NONE)

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

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

#if defined(Py_LIMITED_API) && Py_LIMITED_API+0 >= 0x030D0000

# define Py_NotImplemented Py_GetConstantBorrowed(Py_CONSTANT_NOT_IMPLEMENTED)

# define Py_NotImplemented (&_Py_NotImplementedStruct)

#define Py_RETURN_NOTIMPLEMENTED return 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);

# ifdef Py_GIL_DISABLED

flags = _Py_atomic_load_ulong_relaxed(&type->tp_flags);

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

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

PyAPI_FUNC(PyObject *) PyType_GetModuleByDef(PyTypeObject *, PyModuleDef *);

#ifdef __cplusplus

}

#endif // !Py_OBJECT_H