#include "Python.h"

#include "pycore_abstract.h" // _PyIndex_Check()

#include "pycore_ceval.h" // _PyEval_GetBuiltin()

#include "pycore_freelist.h" // _Py_FREELIST_PUSH()

#include "pycore_gc.h" // _PyObject_GC_IS_TRACKED()

#include "pycore_list.h" // _Py_memory_repeat()

#include "pycore_modsupport.h" // _PyArg_NoKwnames()

#include "pycore_object.h" // _PyObject_GC_TRACK()

#include "pycore_stackref.h" // PyStackRef_AsPyObjectSteal()

#include "pycore_tuple.h" // _PyTupleIterObject

#include "clinic/tupleobject.c.h"

static inline int maybe_freelist_push(PyTupleObject *);

static PyTupleObject *

tuple_alloc(Py_ssize_t size)

{

if (size < 0) {

PyErr_BadInternalCall();

return NULL;

}

assert(size != 0); // The empty tuple is statically allocated.

Py_ssize_t index = size - 1;

if (index < PyTuple_MAXSAVESIZE) {

PyTupleObject *op = _Py_FREELIST_POP(PyTupleObject, tuples[index]);

if (op != NULL) {

_PyTuple_RESET_HASH_CACHE(op);

return op;

}

}

/* Check for overflow */

if ((size_t)size > ((size_t)PY_SSIZE_T_MAX - (sizeof(PyTupleObject) -

sizeof(PyObject *))) / sizeof(PyObject *)) {

return (PyTupleObject *)PyErr_NoMemory();

}

PyTupleObject *result = PyObject_GC_NewVar(PyTupleObject, &PyTuple_Type, size);

if (result != NULL) {

_PyTuple_RESET_HASH_CACHE(result);

}

return result;

}

static inline PyObject *

tuple_get_empty(void)

{

return (PyObject *)&_Py_SINGLETON(tuple_empty);

}

PyObject *

PyTuple_New(Py_ssize_t size)

{

PyTupleObject *op;

if (size == 0) {

return tuple_get_empty();

}

op = tuple_alloc(size);

if (op == NULL) {

return NULL;

}

for (Py_ssize_t i = 0; i < size; i++) {

op->ob_item[i] = NULL;

}

_PyObject_GC_TRACK(op);

return (PyObject *) op;

}

PyTuple_Size(PyObject *op)

{

if (!PyTuple_Check(op)) {

PyErr_BadInternalCall();

return -1;

}

else

return Py_SIZE(op);

}

PyObject *

PyTuple_GetItem(PyObject *op, Py_ssize_t i)

{

if (!PyTuple_Check(op)) {

PyErr_BadInternalCall();

return NULL;

}

if (i < 0 || i >= Py_SIZE(op)) {

PyErr_SetString(PyExc_IndexError, "tuple index out of range");

return NULL;

}

return ((PyTupleObject *)op) -> ob_item[i];

}

PyTuple_SetItem(PyObject *op, Py_ssize_t i, PyObject *newitem)

{

PyObject **p;

if (!PyTuple_Check(op) || !_PyObject_IsUniquelyReferenced(op)) {

Py_XDECREF(newitem);

PyErr_BadInternalCall();

return -1;

}

if (i < 0 || i >= Py_SIZE(op)) {

Py_XDECREF(newitem);

PyErr_SetString(PyExc_IndexError,

"tuple assignment index out of range");

return -1;

}

p = ((PyTupleObject *)op) -> ob_item + i;

Py_XSETREF(*p, newitem);

return 0;

}

_PyTuple_MaybeUntrack(PyObject *op)

{

PyTupleObject *t;

Py_ssize_t i, n;

if (!PyTuple_CheckExact(op) || !_PyObject_GC_IS_TRACKED(op))

return;

t = (PyTupleObject *) op;

n = Py_SIZE(t);

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

PyObject *elt = PyTuple_GET_ITEM(t, i);

/* Tuple with NULL elements aren't

if (!elt ||

_PyObject_GC_MAY_BE_TRACKED(elt))

return;

}

_PyObject_GC_UNTRACK(op);

}

static bool

maybe_tracked(PyObject *ob)

{

return _PyType_IS_GC(Py_TYPE(ob));

}

PyObject *

PyTuple_Pack(Py_ssize_t n, ...)

{

Py_ssize_t i;

PyObject *o;

PyObject **items;

va_list vargs;

bool track = false;

if (n == 0) {

return tuple_get_empty();

}

va_start(vargs, n);

PyTupleObject *result = tuple_alloc(n);

if (result == NULL) {

va_end(vargs);

return NULL;

}

items = result->ob_item;

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

o = va_arg(vargs, PyObject *);

if (!track && maybe_tracked(o)) {

track = true;

}

items[i] = Py_NewRef(o);

}

va_end(vargs);

if (track) {

_PyObject_GC_TRACK(result);

}

return (PyObject *)result;

}

PyObject *

_PyTuple_FromPair(PyObject *first, PyObject *second)

{

assert(first != NULL);

assert(second != NULL);

return _PyTuple_FromPairSteal(Py_NewRef(first), Py_NewRef(second));

}

PyObject *

_PyTuple_FromPairSteal(PyObject *first, PyObject *second)

{

assert(first != NULL);

assert(second != NULL);

PyTupleObject *op = tuple_alloc(2);

if (op == NULL) {

Py_DECREF(first);

Py_DECREF(second);

return NULL;

}

PyObject **items = op->ob_item;

items[0] = first;

items[1] = second;

if (maybe_tracked(first) || maybe_tracked(second)) {

_PyObject_GC_TRACK(op);

}

return (PyObject *)op;

}

_PyStolenTuple_Free(PyObject *obj)

{

assert(PyTuple_CheckExact(obj));

PyTupleObject *op = _PyTuple_CAST(obj);

assert(Py_SIZE(op) != 0);

assert(!_PyObject_GC_IS_TRACKED(obj));

// This will abort on the empty singleton (if there is one).

if (!maybe_freelist_push(op)) {

PyTuple_Type.tp_free((PyObject *)op);

}

}

static void

tuple_dealloc(PyObject *self)

{

PyTupleObject *op = _PyTuple_CAST(self);

if (Py_SIZE(op) == 0) {

/* The empty tuple is statically allocated. */

if (op == &_Py_SINGLETON(tuple_empty)) {

#ifdef Py_DEBUG

_Py_FatalRefcountError("deallocating the empty tuple singleton");

return;

}

#ifdef Py_DEBUG

/* tuple subclasses have their own empty instances. */

assert(!PyTuple_CheckExact(op));

}

PyObject_GC_UnTrack(op);

Py_ssize_t i = Py_SIZE(op);

while (--i >= 0) {

Py_XDECREF(op->ob_item[i]);

}

// This will abort on the empty singleton (if there is one).

if (!maybe_freelist_push(op)) {

Py_TYPE(op)->tp_free((PyObject *)op);

}

}

static PyObject *

tuple_repr(PyObject *self)

{

PyTupleObject *v = _PyTuple_CAST(self);

Py_ssize_t n = PyTuple_GET_SIZE(v);

if (n == 0) {

return PyUnicode_FromString("()");

}

/* While not mutable, it is still possible to end up with a cycle in a

int res = Py_ReprEnter((PyObject *)v);

if (res != 0) {

return res > 0 ? PyUnicode_FromString("(...)") : NULL;

}

Py_ssize_t prealloc;

if (n > 1) {

// "(" + "1" + ", 2" * (len - 1) + ")"

prealloc = 1 + 1 + (2 + 1) * (n - 1) + 1;

}

else {

// "(1,)"

prealloc = 4;

}

PyUnicodeWriter *writer = PyUnicodeWriter_Create(prealloc);

if (writer == NULL) {

goto error;

}

if (PyUnicodeWriter_WriteChar(writer, '(') < 0) {

goto error;

}

/* Do repr() on each element. */

for (Py_ssize_t i = 0; i < n; ++i) {

if (i > 0) {

if (PyUnicodeWriter_WriteChar(writer, ',') < 0) {

goto error;

}

if (PyUnicodeWriter_WriteChar(writer, ' ') < 0) {

goto error;

}

}

if (PyUnicodeWriter_WriteRepr(writer, v->ob_item[i]) < 0) {

goto error;

}

}

if (n == 1) {

if (PyUnicodeWriter_WriteChar(writer, ',') < 0) {

goto error;

}

}

if (PyUnicodeWriter_WriteChar(writer, ')') < 0) {

goto error;

}

Py_ReprLeave((PyObject *)v);

return PyUnicodeWriter_Finish(writer);

error:

PyUnicodeWriter_Discard(writer);

Py_ReprLeave((PyObject *)v);

return NULL;

}

static Py_hash_t

tuple_hash(PyObject *op)

{

PyTupleObject *v = _PyTuple_CAST(op);

Py_uhash_t acc = FT_ATOMIC_LOAD_SSIZE_RELAXED(v->ob_hash);

if (acc != (Py_uhash_t)-1) {

return acc;

}

Py_ssize_t len = Py_SIZE(v);

PyObject **item = v->ob_item;

acc = _PyTuple_HASH_XXPRIME_5;

for (Py_ssize_t i = 0; i < len; i++) {

Py_uhash_t lane = PyObject_Hash(item[i]);

if (lane == (Py_uhash_t)-1) {

return -1;

}

acc += lane * _PyTuple_HASH_XXPRIME_2;

acc = _PyTuple_HASH_XXROTATE(acc);

acc *= _PyTuple_HASH_XXPRIME_1;

}

/* Add input length, mangled to keep the historical value of hash(()). */

acc += len ^ (_PyTuple_HASH_XXPRIME_5 ^ 3527539UL);

if (acc == (Py_uhash_t)-1) {

acc = 1546275796;

}

FT_ATOMIC_STORE_SSIZE_RELAXED(v->ob_hash, acc);

return acc;

}

static Py_ssize_t

tuple_length(PyObject *self)

{

PyTupleObject *a = _PyTuple_CAST(self);

return Py_SIZE(a);

}

static int

tuple_contains(PyObject *self, PyObject *el)

{

PyTupleObject *a = _PyTuple_CAST(self);

int cmp = 0;

for (Py_ssize_t i = 0; cmp == 0 && i < Py_SIZE(a); ++i) {

cmp = PyObject_RichCompareBool(PyTuple_GET_ITEM(a, i), el, Py_EQ);

}

return cmp;

}

static PyObject *

tuple_item(PyObject *op, Py_ssize_t i)

{

PyTupleObject *a = _PyTuple_CAST(op);

if (i < 0 || i >= Py_SIZE(a)) {

PyErr_SetString(PyExc_IndexError, "tuple index out of range");

return NULL;

}

return Py_NewRef(a->ob_item[i]);

}

PyObject *

PyTuple_FromArray(PyObject *const *src, Py_ssize_t n)

{

if (n == 0) {

return tuple_get_empty();

}

PyTupleObject *tuple = tuple_alloc(n);

if (tuple == NULL) {

return NULL;

}

PyObject **dst = tuple->ob_item;

bool track = false;

for (Py_ssize_t i = 0; i < n; i++) {

PyObject *item = src[i];

if (!track && maybe_tracked(item)) {

track = true;

}

dst[i] = Py_NewRef(item);

}

if (track) {

_PyObject_GC_TRACK(tuple);

}

return (PyObject *)tuple;

}

PyObject *

_PyTuple_FromStackRefStealOnSuccess(const _PyStackRef *src, Py_ssize_t n)

{

if (n == 0) {

return tuple_get_empty();

}

PyTupleObject *tuple = tuple_alloc(n);

if (tuple == NULL) {

return NULL;

}

PyObject **dst = tuple->ob_item;

bool track = false;

for (Py_ssize_t i = 0; i < n; i++) {

PyObject *item = PyStackRef_AsPyObjectSteal(src[i]);

if (!track && maybe_tracked(item)) {

track = true;

}

dst[i] = item;

}

if (track) {

_PyObject_GC_TRACK(tuple);

}

return (PyObject *)tuple;

}

PyObject *

_PyTuple_FromArraySteal(PyObject *const *src, Py_ssize_t n)

{

if (n == 0) {

return tuple_get_empty();

}

PyTupleObject *tuple = tuple_alloc(n);

if (tuple == NULL) {

for (Py_ssize_t i = 0; i < n; i++) {

Py_DECREF(src[i]);

}

return NULL;

}

PyObject **dst = tuple->ob_item;

for (Py_ssize_t i = 0; i < n; i++) {

PyObject *item = src[i];

dst[i] = item;

}

_PyObject_GC_TRACK(tuple);

return (PyObject *)tuple;

}

static PyObject *

tuple_slice(PyTupleObject *a, Py_ssize_t ilow,

Py_ssize_t ihigh)

{

if (ilow < 0)

ilow = 0;

if (ihigh > Py_SIZE(a))

ihigh = Py_SIZE(a);

if (ihigh < ilow)

ihigh = ilow;

if (ilow == 0 && ihigh == Py_SIZE(a) && PyTuple_CheckExact(a)) {

return Py_NewRef(a);

}

return PyTuple_FromArray(a->ob_item + ilow, ihigh - ilow);

}

PyObject *

_PyTuple_BinarySlice(PyObject *container, PyObject *start, PyObject *stop)

{

assert(PyTuple_CheckExact(container));

Py_ssize_t len = Py_SIZE(container);

Py_ssize_t istart, istop;

if (!_PyEval_UnpackIndices(start, stop, len, &istart, &istop)) {

return NULL;

}

if (istart == 0 && istop == len) {

return Py_NewRef(container);

}

if (istop < istart) {

istop = istart;

}

return PyTuple_FromArray(((PyTupleObject *)container)->ob_item + istart,

istop - istart);

}

PyObject *

PyTuple_GetSlice(PyObject *op, Py_ssize_t i, Py_ssize_t j)

{

if (op == NULL || !PyTuple_Check(op)) {

PyErr_BadInternalCall();

return NULL;

}

return tuple_slice((PyTupleObject *)op, i, j);

}

PyObject *

_PyTuple_Concat(PyObject *aa, PyObject *bb)

{

PyTupleObject *a = _PyTuple_CAST(aa);

if (Py_SIZE(a) == 0 && PyTuple_CheckExact(bb)) {

return Py_NewRef(bb);

}

if (!PyTuple_Check(bb)) {

PyErr_Format(PyExc_TypeError,

"can only concatenate tuple (not \"%.200s\") to tuple",

Py_TYPE(bb)->tp_name);

return NULL;

}

PyTupleObject *b = (PyTupleObject *)bb;

if (Py_SIZE(b) == 0 && PyTuple_CheckExact(a)) {

return Py_NewRef(a);

}

assert((size_t)Py_SIZE(a) + (size_t)Py_SIZE(b) < PY_SSIZE_T_MAX);

Py_ssize_t size = Py_SIZE(a) + Py_SIZE(b);

if (size == 0) {

return tuple_get_empty();

}

PyTupleObject *np = tuple_alloc(size);

if (np == NULL) {

return NULL;

}

PyObject **src = a->ob_item;

PyObject **dest = np->ob_item;

for (Py_ssize_t i = 0; i < Py_SIZE(a); i++) {

PyObject *v = src[i];

dest[i] = Py_NewRef(v);

}

src = b->ob_item;

dest = np->ob_item + Py_SIZE(a);

for (Py_ssize_t i = 0; i < Py_SIZE(b); i++) {

PyObject *v = src[i];

dest[i] = Py_NewRef(v);

}

_PyObject_GC_TRACK(np);

return (PyObject *)np;

}

static PyObject *

tuple_repeat(PyObject *self, Py_ssize_t n)

{

PyTupleObject *a = _PyTuple_CAST(self);

const Py_ssize_t input_size = Py_SIZE(a);

if (input_size == 0 || n == 1) {

if (PyTuple_CheckExact(a)) {

/* Since tuples are immutable, we can return a shared

return Py_NewRef(a);

}

}

if (input_size == 0 || n <= 0) {

return tuple_get_empty();

}

assert(n>0);

if (input_size > PY_SSIZE_T_MAX / n)

return PyErr_NoMemory();

Py_ssize_t output_size = input_size * n;

PyTupleObject *np = tuple_alloc(output_size);

if (np == NULL)

return NULL;

PyObject **dest = np->ob_item;

if (input_size == 1) {

PyObject *elem = a->ob_item[0];

_Py_RefcntAdd(elem, n);

PyObject **dest_end = dest + output_size;

while (dest < dest_end) {

*dest++ = elem;

}

}

else {

PyObject **src = a->ob_item;

PyObject **src_end = src + input_size;

while (src < src_end) {

_Py_RefcntAdd(*src, n);

*dest++ = *src++;

}

_Py_memory_repeat((char *)np->ob_item, sizeof(PyObject *)*output_size,

sizeof(PyObject *)*input_size);

}

_PyObject_GC_TRACK(np);

return (PyObject *) np;

}

static PyObject *

tuple_index_impl(PyTupleObject *self, PyObject *value, Py_ssize_t start,

Py_ssize_t stop)

{

Py_ssize_t i;

if (start < 0) {

start += Py_SIZE(self);

if (start < 0)

start = 0;

}

if (stop < 0) {

stop += Py_SIZE(self);

}

else if (stop > Py_SIZE(self)) {

stop = Py_SIZE(self);

}

for (i = start; i < stop; i++) {

int cmp = PyObject_RichCompareBool(self->ob_item[i], value, Py_EQ);

if (cmp > 0)

return PyLong_FromSsize_t(i);

else if (cmp < 0)

return NULL;

}

PyErr_SetString(PyExc_ValueError, "tuple.index(x): x not in tuple");

return NULL;

}

static PyObject *

tuple_count_impl(PyTupleObject *self, PyObject *value)

{

Py_ssize_t count = 0;

Py_ssize_t i;

for (i = 0; i < Py_SIZE(self); i++) {

int cmp = PyObject_RichCompareBool(self->ob_item[i], value, Py_EQ);

if (cmp > 0)

count++;

else if (cmp < 0)

return NULL;

}

return PyLong_FromSsize_t(count);

}

static int

tuple_traverse(PyObject *self, visitproc visit, void *arg)

{

PyTupleObject *o = _PyTuple_CAST(self);

for (Py_ssize_t i = Py_SIZE(o); --i >= 0; ) {

Py_VISIT(o->ob_item[i]);

}

return 0;

}

static PyObject *

tuple_richcompare(PyObject *v, PyObject *w, int op)

{

PyTupleObject *vt, *wt;

Py_ssize_t i;

Py_ssize_t vlen, wlen;

if (!PyTuple_Check(v) || !PyTuple_Check(w))

Py_RETURN_NOTIMPLEMENTED;

vt = (PyTupleObject *)v;

wt = (PyTupleObject *)w;

vlen = Py_SIZE(vt);

wlen = Py_SIZE(wt);

/* Note: the corresponding code for lists has an "early out" test

/* Search for the first index where items are different.

for (i = 0; i < vlen && i < wlen; i++) {

int k = PyObject_RichCompareBool(vt->ob_item[i],

wt->ob_item[i], Py_EQ);

if (k < 0)

return NULL;

if (!k)

break;

}

if (i >= vlen || i >= wlen) {

/* No more items to compare -- compare sizes */

Py_RETURN_RICHCOMPARE(vlen, wlen, op);

}

/* We have an item that differs -- shortcuts for EQ/NE */

if (op == Py_EQ) {

Py_RETURN_FALSE;

}

if (op == Py_NE) {

Py_RETURN_TRUE;

}

/* Compare the final item again using the proper operator */

return PyObject_RichCompare(vt->ob_item[i], wt->ob_item[i], op);

}

static PyObject *

tuple_subtype_new(PyTypeObject *type, PyObject *iterable);

static PyObject *

tuple_new_impl(PyTypeObject *type, PyObject *iterable)

{

if (type != &PyTuple_Type)

return tuple_subtype_new(type, iterable);

if (iterable == NULL) {

return tuple_get_empty();

}

else {

return PySequence_Tuple(iterable);

}

}

static PyObject *

tuple_vectorcall(PyObject *type, PyObject * const*args,

size_t nargsf, PyObject *kwnames)

{

if (!_PyArg_NoKwnames("tuple", kwnames)) {

return NULL;

}

Py_ssize_t nargs = PyVectorcall_NARGS(nargsf);

if (!_PyArg_CheckPositional("tuple", nargs, 0, 1)) {

return NULL;

}

if (nargs) {

return tuple_new_impl(_PyType_CAST(type), args[0]);

}

else {

return tuple_get_empty();

}

}

static PyObject *

tuple_subtype_new(PyTypeObject *type, PyObject *iterable)

{

PyObject *tmp, *newobj, *item;

Py_ssize_t i, n;

assert(PyType_IsSubtype(type, &PyTuple_Type));

// tuple subclasses must implement the GC protocol

assert(_PyType_IS_GC(type));

tmp = tuple_new_impl(&PyTuple_Type, iterable);

if (tmp == NULL)

return NULL;

assert(PyTuple_Check(tmp));

/* This may allocate an empty tuple that is not the global one. */

newobj = type->tp_alloc(type, n = PyTuple_GET_SIZE(tmp));

if (newobj == NULL) {

Py_DECREF(tmp);

return NULL;

}

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

item = PyTuple_GET_ITEM(tmp, i);

PyTuple_SET_ITEM(newobj, i, Py_NewRef(item));

}

Py_DECREF(tmp);

_PyTuple_RESET_HASH_CACHE(newobj);

// Don't track if a subclass tp_alloc is PyType_GenericAlloc()

if (!_PyObject_GC_IS_TRACKED(newobj)) {

_PyObject_GC_TRACK(newobj);

}

return newobj;

}

static PySequenceMethods tuple_as_sequence = {

tuple_length, /* sq_length */

_PyTuple_Concat, /* sq_concat */

tuple_repeat, /* sq_repeat */

tuple_item, /* sq_item */

0, /* sq_slice */

0, /* sq_ass_item */

0, /* sq_ass_slice */

tuple_contains, /* sq_contains */

};

static _PyObjectIndexPair

tuple_iteritem(PyObject *obj, Py_ssize_t index)

{

if (index >= PyTuple_GET_SIZE(obj)) {

return (_PyObjectIndexPair) { .object = NULL, .index = index };

}

PyObject *result = PyTuple_GET_ITEM(obj, index);

Py_INCREF(result);

return (_PyObjectIndexPair) { .object = result, .index = index + 1 };

}

static PyObject*

tuple_subscript(PyObject *op, PyObject* item)

{

PyTupleObject *self = _PyTuple_CAST(op);

if (_PyIndex_Check(item)) {

Py_ssize_t i = PyNumber_AsSsize_t(item, PyExc_IndexError);

if (i == -1 && PyErr_Occurred())

return NULL;

if (i < 0)

i += PyTuple_GET_SIZE(self);

return tuple_item(op, i);

}

else if (PySlice_Check(item)) {

Py_ssize_t start, stop, step, slicelength, i;

size_t cur;

PyObject* it;

PyObject **src, **dest;

if (PySlice_Unpack(item, &start, &stop, &step) < 0) {

return NULL;

}

slicelength = PySlice_AdjustIndices(PyTuple_GET_SIZE(self), &start,

&stop, step);

if (slicelength <= 0) {

return tuple_get_empty();

}

else if (start == 0 && step == 1 &&

slicelength == PyTuple_GET_SIZE(self) &&

PyTuple_CheckExact(self)) {

return Py_NewRef(self);

}

else {

PyTupleObject* result = tuple_alloc(slicelength);

if (!result) return NULL;

src = self->ob_item;

dest = result->ob_item;

for (cur = start, i = 0; i < slicelength;

cur += step, i++) {

it = Py_NewRef(src[cur]);

dest[i] = it;

}

_PyObject_GC_TRACK(result);

return (PyObject *)result;

}

}

else {

PyErr_Format(PyExc_TypeError,

"tuple indices must be integers or slices, not %.200s",

Py_TYPE(item)->tp_name);

return NULL;

}

}

static PyObject *

tuple___getnewargs___impl(PyTupleObject *self)

{

return Py_BuildValue("(N)", tuple_slice(self, 0, Py_SIZE(self)));

}

static PyMethodDef tuple_methods[] = {

TUPLE___GETNEWARGS___METHODDEF

TUPLE_INDEX_METHODDEF

TUPLE_COUNT_METHODDEF

{"__class_getitem__", Py_GenericAlias, METH_O|METH_CLASS, PyDoc_STR("See PEP 585")},

{NULL, NULL} /* sentinel */

};

static PyMappingMethods tuple_as_mapping = {

tuple_length,

tuple_subscript,

0

};

static PyObject *tuple_iter(PyObject *seq);

PyTypeObject PyTuple_Type = {

PyVarObject_HEAD_INIT(&PyType_Type, 0)

"tuple",

sizeof(PyTupleObject) - sizeof(PyObject *),

sizeof(PyObject *),

tuple_dealloc, /* tp_dealloc */

0, /* tp_vectorcall_offset */

0, /* tp_getattr */

0, /* tp_setattr */

0, /* tp_as_async */

tuple_repr, /* tp_repr */

0, /* tp_as_number */

&tuple_as_sequence, /* tp_as_sequence */

&tuple_as_mapping, /* tp_as_mapping */

tuple_hash, /* tp_hash */

0, /* tp_call */

0, /* tp_str */

PyObject_GenericGetAttr, /* tp_getattro */

0, /* tp_setattro */

0, /* tp_as_buffer */

Py_TPFLAGS_DEFAULT | Py_TPFLAGS_HAVE_GC |

Py_TPFLAGS_BASETYPE | Py_TPFLAGS_TUPLE_SUBCLASS |

_Py_TPFLAGS_MATCH_SELF | Py_TPFLAGS_SEQUENCE, /* tp_flags */

tuple_new__doc__, /* tp_doc */

tuple_traverse, /* tp_traverse */

0, /* tp_clear */

tuple_richcompare, /* tp_richcompare */

0, /* tp_weaklistoffset */

tuple_iter, /* tp_iter */

0, /* tp_iternext */

tuple_methods, /* tp_methods */