#ifndef PYTHONCAPI_COMPAT

#define PYTHONCAPI_COMPAT

#ifdef __cplusplus

extern "C" {

#endif

#include <Python.h>

#include <stddef.h> // offsetof()

#if PY_VERSION_HEX < 0x030b00B4 && !defined(PYPY_VERSION)

# include "frameobject.h" // PyFrameObject, PyFrame_GetBack()

#endif

#ifndef _Py_CAST

# define _Py_CAST(type, expr) ((type)(expr))

#endif

#ifndef _Py_NULL

# if (defined (__STDC_VERSION__) && __STDC_VERSION__ > 201710L) \

|| (defined(__cplusplus) && __cplusplus >= 201103)

# define _Py_NULL nullptr

# else

# define _Py_NULL NULL

# endif

#endif

#ifndef _PyObject_CAST

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

#endif

#ifndef Py_BUILD_ASSERT

# define Py_BUILD_ASSERT(cond) \

do { \

(void)sizeof(char [1 - 2 * !(cond)]); \

} while(0)

#endif

#if PY_VERSION_HEX < 0x030A00A3 && !defined(Py_NewRef)

static inline PyObject* _Py_NewRef(PyObject *obj)

{

Py_INCREF(obj);

return obj;

}

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

#endif

#if PY_VERSION_HEX < 0x030A00A3 && !defined(Py_XNewRef)

static inline PyObject* _Py_XNewRef(PyObject *obj)

{

Py_XINCREF(obj);

return obj;

}

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

#endif

#if PY_VERSION_HEX < 0x030900A4 && !defined(Py_SET_REFCNT)

static inline void _Py_SET_REFCNT(PyObject *ob, Py_ssize_t refcnt)

{

ob->ob_refcnt = refcnt;

}

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

#endif

#if (PY_VERSION_HEX < 0x03050200 && !defined(Py_SETREF)) && !defined(Py_LIMITED_API)

#define Py_SETREF(dst, src) \

do { \

PyObject **_tmp_dst_ptr = _Py_CAST(PyObject**, &(dst)); \

PyObject *_tmp_dst = (*_tmp_dst_ptr); \

*_tmp_dst_ptr = _PyObject_CAST(src); \

Py_DECREF(_tmp_dst); \

} while (0)

#define Py_XSETREF(dst, src) \

do { \

PyObject **_tmp_dst_ptr = _Py_CAST(PyObject**, &(dst)); \

PyObject *_tmp_dst = (*_tmp_dst_ptr); \

*_tmp_dst_ptr = _PyObject_CAST(src); \

Py_XDECREF(_tmp_dst); \

} while (0)

#endif

#if PY_VERSION_HEX < 0x030A00B1 && !defined(Py_Is)

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

#endif

#if PY_VERSION_HEX < 0x030A00B1 && !defined(Py_IsNone)

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

#endif

#if (PY_VERSION_HEX < 0x030A00B1 || defined(PYPY_VERSION)) && !defined(Py_IsTrue)

# define Py_IsTrue(x) Py_Is(x, Py_True)

#endif

#if (PY_VERSION_HEX < 0x030A00B1 || defined(PYPY_VERSION)) && !defined(Py_IsFalse)

# define Py_IsFalse(x) Py_Is(x, Py_False)

#endif

#if PY_VERSION_HEX < 0x030900A4 && !defined(Py_SET_TYPE)

static inline void _Py_SET_TYPE(PyObject *ob, PyTypeObject *type)

{

ob->ob_type = type;

}

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

#endif

#if PY_VERSION_HEX < 0x030900A4 && !defined(Py_SET_SIZE)

static inline void _Py_SET_SIZE(PyVarObject *ob, Py_ssize_t size)

{

ob->ob_size = size;

}

#define Py_SET_SIZE(ob, size) _Py_SET_SIZE((PyVarObject*)(ob), size)

#endif

#if PY_VERSION_HEX < 0x030900B1 || defined(PYPY_VERSION)

static inline PyCodeObject* PyFrame_GetCode(PyFrameObject *frame)

{

assert(frame != _Py_NULL);

assert(frame->f_code != _Py_NULL);

return _Py_CAST(PyCodeObject*, Py_NewRef(frame->f_code));

}

#endif

static inline PyCodeObject* _PyFrame_GetCodeBorrow(PyFrameObject *frame)

{

PyCodeObject *code = PyFrame_GetCode(frame);

Py_DECREF(code);

return code;

}

#if PY_VERSION_HEX < 0x030900B1 && !defined(PYPY_VERSION)

static inline PyFrameObject* PyFrame_GetBack(PyFrameObject *frame)

{

assert(frame != _Py_NULL);

return _Py_CAST(PyFrameObject*, Py_XNewRef(frame->f_back));

}

#endif

#if !defined(PYPY_VERSION)

static inline PyFrameObject* _PyFrame_GetBackBorrow(PyFrameObject *frame)

{

PyFrameObject *back = PyFrame_GetBack(frame);

Py_XDECREF(back);

return back;

}

#endif

#if PY_VERSION_HEX < 0x030B00A7 && !defined(PYPY_VERSION)

static inline PyObject* PyFrame_GetLocals(PyFrameObject *frame)

{

#if PY_VERSION_HEX >= 0x030400B1

if (PyFrame_FastToLocalsWithError(frame) < 0) {

return NULL;

}

#else

PyFrame_FastToLocals(frame);

#endif

return Py_NewRef(frame->f_locals);

}

#endif

#if PY_VERSION_HEX < 0x030B00A7 && !defined(PYPY_VERSION)

static inline PyObject* PyFrame_GetGlobals(PyFrameObject *frame)

{

return Py_NewRef(frame->f_globals);

}

#endif

#if PY_VERSION_HEX < 0x030B00A7 && !defined(PYPY_VERSION)

static inline PyObject* PyFrame_GetBuiltins(PyFrameObject *frame)

{

return Py_NewRef(frame->f_builtins);

}

#endif

#if PY_VERSION_HEX < 0x030B00B1 && !defined(PYPY_VERSION)

static inline int PyFrame_GetLasti(PyFrameObject *frame)

}

#endif

#if PY_VERSION_HEX < 0x030C00A2 && !defined(PYPY_VERSION)

static inline PyObject* PyFrame_GetVar(PyFrameObject *frame, PyObject *name)

{

PyObject *locals, *value;

locals = PyFrame_GetLocals(frame);

if (locals == NULL) {

return NULL;

}

#if PY_VERSION_HEX >= 0x03000000

value = PyDict_GetItemWithError(locals, name);

#else

value = _PyDict_GetItemWithError(locals, name);

#endif

Py_DECREF(locals);

if (value == NULL) {

if (PyErr_Occurred()) {

return NULL;

}

#if PY_VERSION_HEX >= 0x03000000

PyErr_Format(PyExc_NameError, "variable %R does not exist", name);

#else

PyErr_SetString(PyExc_NameError, "variable does not exist");

#endif

return NULL;

}

return Py_NewRef(value);

}

#endif

#if PY_VERSION_HEX < 0x030C00A2 && !defined(PYPY_VERSION)

static inline PyObject*

PyFrame_GetVarString(PyFrameObject *frame, const char *name)

{

PyObject *name_obj, *value;

#if PY_VERSION_HEX >= 0x03000000

name_obj = PyUnicode_FromString(name);

#else

name_obj = PyString_FromString(name);

#endif

if (name_obj == NULL) {

return NULL;

}

value = PyFrame_GetVar(frame, name_obj);

Py_DECREF(name_obj);

return value;

}

#endif

#if PY_VERSION_HEX < 0x030900A5 || (defined(PYPY_VERSION) && PY_VERSION_HEX < 0x030B0000)

static inline PyInterpreterState *

PyThreadState_GetInterpreter(PyThreadState *tstate)

{

assert(tstate != _Py_NULL);

return tstate->interp;

}

#endif

#if PY_VERSION_HEX < 0x030900B1 && !defined(PYPY_VERSION)

static inline PyFrameObject* PyThreadState_GetFrame(PyThreadState *tstate)

{

assert(tstate != _Py_NULL);

return _Py_CAST(PyFrameObject *, Py_XNewRef(tstate->frame));

}

#endif

#if !defined(PYPY_VERSION)

static inline PyFrameObject*

_PyThreadState_GetFrameBorrow(PyThreadState *tstate)

{

PyFrameObject *frame = PyThreadState_GetFrame(tstate);

Py_XDECREF(frame);

return frame;

}

#endif

#if PY_VERSION_HEX < 0x030900A5 || defined(PYPY_VERSION)

static inline PyInterpreterState* PyInterpreterState_Get(void)

{

PyThreadState *tstate;

PyInterpreterState *interp;

tstate = PyThreadState_GET();

if (tstate == _Py_NULL) {

Py_FatalError("GIL released (tstate is NULL)");

}

interp = tstate->interp;

if (interp == _Py_NULL) {

Py_FatalError("no current interpreter");

}

return interp;

}

#endif

#if 0x030700A1 <= PY_VERSION_HEX && PY_VERSION_HEX < 0x030900A6 && !defined(PYPY_VERSION)

static inline uint64_t PyThreadState_GetID(PyThreadState *tstate)

}

#endif

#if PY_VERSION_HEX < 0x030B00A2 && !defined(PYPY_VERSION)

static inline void PyThreadState_EnterTracing(PyThreadState *tstate)

}

#endif

#if PY_VERSION_HEX < 0x030B00A2 && !defined(PYPY_VERSION)

static inline void PyThreadState_LeaveTracing(PyThreadState *tstate)

}

#endif

#if !defined(PyObject_CallNoArgs) && PY_VERSION_HEX < 0x030900A1

static inline PyObject* PyObject_CallNoArgs(PyObject *func)

{

return PyObject_CallFunctionObjArgs(func, NULL);

}

#endif

#if !defined(PyObject_CallOneArg) && PY_VERSION_HEX < 0x030900A4

static inline PyObject* PyObject_CallOneArg(PyObject *func, PyObject *arg)

{

return PyObject_CallFunctionObjArgs(func, arg, NULL);

}

#endif

#if PY_VERSION_HEX < 0x030A00A3

static inline int

PyModule_AddObjectRef(PyObject *module, const char *name, PyObject *value)

}

#endif

#if PY_VERSION_HEX < 0x030900A5

static inline int PyModule_AddType(PyObject *module, PyTypeObject *type)

}

#endif

#if PY_VERSION_HEX < 0x030900A6 && !defined(PYPY_VERSION)

static inline int PyObject_GC_IsTracked(PyObject* obj)

{

return (PyObject_IS_GC(obj) && _PyObject_GC_IS_TRACKED(obj));

}

#endif

#if PY_VERSION_HEX < 0x030900A6 && PY_VERSION_HEX >= 0x030400F0 && !defined(PYPY_VERSION)

static inline int PyObject_GC_IsFinalized(PyObject *obj)

}

#endif

#if PY_VERSION_HEX < 0x030900A4 && !defined(Py_IS_TYPE)

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

return Py_TYPE(ob) == type;

}

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

#endif

#if 0x030600B1 <= PY_VERSION_HEX && PY_VERSION_HEX <= 0x030B00A1 && !defined(PYPY_VERSION)

static inline int PyFloat_Pack2(double x, char *p, int le)

{ return _PyFloat_Pack2(x, (unsigned char*)p, le); }

static inline double PyFloat_Unpack2(const char *p, int le)

{ return _PyFloat_Unpack2((const unsigned char *)p, le); }

#endif

#if PY_VERSION_HEX <= 0x030B00A1 && !defined(PYPY_VERSION)

static inline int PyFloat_Pack4(double x, char *p, int le)

{ return _PyFloat_Pack4(x, (unsigned char*)p, le); }

static inline int PyFloat_Pack8(double x, char *p, int le)

{ return _PyFloat_Pack8(x, (unsigned char*)p, le); }

static inline double PyFloat_Unpack4(const char *p, int le)

{ return _PyFloat_Unpack4((const unsigned char *)p, le); }

static inline double PyFloat_Unpack8(const char *p, int le)

{ return _PyFloat_Unpack8((const unsigned char *)p, le); }

#endif

#if PY_VERSION_HEX < 0x030B00B1 && !defined(PYPY_VERSION)

static inline PyObject* PyCode_GetCode(PyCodeObject *code)

{

return Py_NewRef(code->co_code);

}

#endif

#if PY_VERSION_HEX < 0x030B00C1 && !defined(PYPY_VERSION)

static inline PyObject* PyCode_GetVarnames(PyCodeObject *code)

{

return Py_NewRef(code->co_varnames);

}

#endif

#if PY_VERSION_HEX < 0x030B00C1 && !defined(PYPY_VERSION)

static inline PyObject* PyCode_GetFreevars(PyCodeObject *code)

{

return Py_NewRef(code->co_freevars);

}

#endif

#if PY_VERSION_HEX < 0x030B00C1 && !defined(PYPY_VERSION)

static inline PyObject* PyCode_GetCellvars(PyCodeObject *code)

{

return Py_NewRef(code->co_cellvars);

}

#endif

#if PY_VERSION_HEX < 0x030400B2 && !defined(Py_UNUSED)

# if defined(__GNUC__) || defined(__clang__)

# define Py_UNUSED(name) _unused_ ## name __attribute__((unused))

# else

# define Py_UNUSED(name) _unused_ ## name

# endif

#endif

#if PY_VERSION_HEX < 0x030D00A0

static inline PyObject* PyImport_AddModuleRef(const char *name)

{

return Py_XNewRef(PyImport_AddModule(name));

}

#endif

#if PY_VERSION_HEX < 0x030D0000

static inline int PyWeakref_GetRef(PyObject *ref, PyObject **pobj)

}

#endif

#ifndef PY_VECTORCALL_ARGUMENTS_OFFSET

# define PY_VECTORCALL_ARGUMENTS_OFFSET (_Py_CAST(size_t, 1) << (8 * sizeof(size_t) - 1))

#endif

#if PY_VERSION_HEX < 0x030800B1

static inline Py_ssize_t PyVectorcall_NARGS(size_t n)

{

return n & ~PY_VECTORCALL_ARGUMENTS_OFFSET;

}

#endif

#if PY_VERSION_HEX < 0x030900A4

static inline PyObject*

PyObject_Vectorcall(PyObject *callable, PyObject *const *args,

size_t nargsf, PyObject *kwnames)

{

#if PY_VERSION_HEX >= 0x030800B1 && !defined(PYPY_VERSION)

// bpo-36974 added _PyObject_Vectorcall() to Python 3.8.0b1

return _PyObject_Vectorcall(callable, args, nargsf, kwnames);

#else

PyObject *posargs = NULL, *kwargs = NULL;

PyObject *res;

Py_ssize_t nposargs, nkwargs, i;

if (nargsf != 0 && args == NULL) {

PyErr_BadInternalCall();

goto error;

}

if (kwnames != NULL && !PyTuple_Check(kwnames)) {

PyErr_BadInternalCall();

goto error;

}

nposargs = (Py_ssize_t)PyVectorcall_NARGS(nargsf);

if (kwnames) {

nkwargs = PyTuple_GET_SIZE(kwnames);

}

else {

nkwargs = 0;

}

posargs = PyTuple_New(nposargs);

if (posargs == NULL) {

goto error;

}

if (nposargs) {

for (i=0; i < nposargs; i++) {

PyTuple_SET_ITEM(posargs, i, Py_NewRef(*args));

args++;

}

}

if (nkwargs) {

kwargs = PyDict_New();

if (kwargs == NULL) {

goto error;

}

for (i = 0; i < nkwargs; i++) {

PyObject *key = PyTuple_GET_ITEM(kwnames, i);

PyObject *value = *args;

args++;

if (PyDict_SetItem(kwargs, key, value) < 0) {

goto error;

}

}

}

else {

kwargs = NULL;

}

res = PyObject_Call(callable, posargs, kwargs);

Py_DECREF(posargs);

Py_XDECREF(kwargs);

return res;

error:

Py_DECREF(posargs);

Py_XDECREF(kwargs);

return NULL;

#endif

}

#endif

#if PY_VERSION_HEX < 0x030D00A1

static inline int

PyObject_GetOptionalAttr(PyObject *obj, PyObject *attr_name, PyObject **result)

}

static inline int

PyObject_GetOptionalAttrString(PyObject *obj, const char *attr_name, PyObject **result)

}

#endif

#if PY_VERSION_HEX < 0x030D00A1

static inline int

PyMapping_GetOptionalItem(PyObject *obj, PyObject *key, PyObject **result)

}

static inline int

PyMapping_GetOptionalItemString(PyObject *obj, const char *key, PyObject **result)

}

#endif

#if PY_VERSION_HEX < 0x030D00A1

static inline int

PyMapping_HasKeyWithError(PyObject *obj, PyObject *key)

}

static inline int

PyMapping_HasKeyStringWithError(PyObject *obj, const char *key)

}

#endif

#if PY_VERSION_HEX < 0x030D00A1

static inline int

PyObject_HasAttrWithError(PyObject *obj, PyObject *attr)

}

static inline int

PyObject_HasAttrStringWithError(PyObject *obj, const char *attr)

}

#endif

#if PY_VERSION_HEX < 0x030D00A1

static inline int

PyDict_GetItemRef(PyObject *mp, PyObject *key, PyObject **result)

}

static inline int

PyDict_GetItemStringRef(PyObject *mp, const char *key, PyObject **result)

}

#endif

#if PY_VERSION_HEX < 0x030D00A1

static inline int

PyModule_Add(PyObject *mod, const char *name, PyObject *value)

}

#endif

#if (0x030201B1 <= PY_VERSION_HEX && PY_VERSION_HEX < 0x030D00A1) \

&& (!defined(PYPY_VERSION_NUM) || PYPY_VERSION_NUM >= 0x7030000)

static inline int Py_IsFinalizing(void)

}

#endif

#if PY_VERSION_HEX < 0x030D00A1

static inline int PyDict_ContainsString(PyObject *op, const char *key)

}

#endif

#if PY_VERSION_HEX < 0x030D00A1

static inline int PyLong_AsInt(PyObject *obj)

}

#endif

#if PY_VERSION_HEX < 0x030D00A1

static inline int

PyObject_VisitManagedDict(PyObject *obj, visitproc visit, void *arg)

}

static inline void

PyObject_ClearManagedDict(PyObject *obj)

}

#endif

#if PY_VERSION_HEX >= 0x03050200 && PY_VERSION_HEX < 0x030D00A1

static inline PyThreadState*

PyThreadState_GetUnchecked(void)

{

return _PyThreadState_UncheckedGet();

}

#endif

#if PY_VERSION_HEX < 0x030D00A1

static inline int

PyUnicode_EqualToUTF8AndSize(PyObject *unicode, const char *str, Py_ssize_t str_len)