diff --git a/Modules/_operator.c b/Modules/_operator.c
--- a/Modules/_operator.c
+++ b/Modules/_operator.c
@@ -1,6 +1,13 @@
 
 #include "Python.h"
 
+#include "clinic/_operator.c.h"
+
+/*[clinic input]
+module _operator
+[clinic start generated code]*/
+/*[clinic end generated code: output=da39a3ee5e6b4b0d input=672ecf48487521e7]*/
+
 PyDoc_STRVAR(operator_doc,
 "Operator interface.\n\
 \n\
@@ -10,158 +17,710 @@
 used for special methods; variants without leading and trailing\n\
 '__' are also provided for convenience.");
 
-#define spam1(OP,AOP) static PyObject *OP(PyObject *s, PyObject *a1) { \
-  return AOP(a1); }
 
-#define spam2(OP,AOP) static PyObject *OP(PyObject *s, PyObject *a) { \
-  PyObject *a1, *a2; \
-  if(! PyArg_UnpackTuple(a,#OP,2,2,&a1,&a2)) return NULL; \
-  return AOP(a1,a2); }
+/*[clinic input]
+_operator.truth -> bool
 
-#define spamoi(OP,AOP) static PyObject *OP(PyObject *s, PyObject *a) { \
-  PyObject *a1; int a2; \
-  if(! PyArg_ParseTuple(a,"Oi:" #OP,&a1,&a2)) return NULL; \
-  return AOP(a1,a2); }
+    a: object
+    /
 
-#define spam2n(OP,AOP) static PyObject *OP(PyObject *s, PyObject *a) { \
-  PyObject *a1, *a2; \
-  if(! PyArg_UnpackTuple(a,#OP,2,2,&a1,&a2)) return NULL; \
-  if(-1 == AOP(a1,a2)) return NULL; \
-  Py_INCREF(Py_None); \
-  return Py_None; }
+Return True if a is true, False otherwise.
+[clinic start generated code]*/
 
-#define spam3n(OP,AOP) static PyObject *OP(PyObject *s, PyObject *a) { \
-  PyObject *a1, *a2, *a3; \
-  if(! PyArg_UnpackTuple(a,#OP,3,3,&a1,&a2,&a3)) return NULL; \
-  if(-1 == AOP(a1,a2,a3)) return NULL; \
-  Py_INCREF(Py_None); \
-  return Py_None; }
-
-#define spami(OP,AOP) static PyObject *OP(PyObject *s, PyObject *a1) { \
-  long r; \
-  if(-1 == (r=AOP(a1))) return NULL; \
-  return PyBool_FromLong(r); }
-
-#define spami2(OP,AOP) static PyObject *OP(PyObject *s, PyObject *a) { \
-  PyObject *a1, *a2; long r; \
-  if(! PyArg_UnpackTuple(a,#OP,2,2,&a1,&a2)) return NULL; \
-  if(-1 == (r=AOP(a1,a2))) return NULL; \
-  return PyLong_FromLong(r); }
-
-#define spamn2(OP,AOP) static PyObject *OP(PyObject *s, PyObject *a) { \
-  PyObject *a1, *a2; Py_ssize_t r; \
-  if(! PyArg_UnpackTuple(a,#OP,2,2,&a1,&a2)) return NULL; \
-  if(-1 == (r=AOP(a1,a2))) return NULL; \
-  return PyLong_FromSsize_t(r); }
-
-#define spami2b(OP,AOP) static PyObject *OP(PyObject *s, PyObject *a) { \
-  PyObject *a1, *a2; long r; \
-  if(! PyArg_UnpackTuple(a,#OP,2,2,&a1,&a2)) return NULL; \
-  if(-1 == (r=AOP(a1,a2))) return NULL; \
-  return PyBool_FromLong(r); }
-
-#define spamrc(OP,A) static PyObject *OP(PyObject *s, PyObject *a) { \
-  PyObject *a1, *a2; \
-  if(! PyArg_UnpackTuple(a,#OP,2,2,&a1,&a2)) return NULL; \
-  return PyObject_RichCompare(a1,a2,A); }
-
-spami(truth            , PyObject_IsTrue)
-spam2(op_add           , PyNumber_Add)
-spam2(op_sub           , PyNumber_Subtract)
-spam2(op_mul           , PyNumber_Multiply)
-spam2(op_matmul        , PyNumber_MatrixMultiply)
-spam2(op_floordiv      , PyNumber_FloorDivide)
-spam2(op_truediv       , PyNumber_TrueDivide)
-spam2(op_mod           , PyNumber_Remainder)
-spam1(op_neg           , PyNumber_Negative)
-spam1(op_pos           , PyNumber_Positive)
-spam1(op_abs           , PyNumber_Absolute)
-spam1(op_inv           , PyNumber_Invert)
-spam1(op_invert        , PyNumber_Invert)
-spam2(op_lshift        , PyNumber_Lshift)
-spam2(op_rshift        , PyNumber_Rshift)
-spami(op_not_          , PyObject_Not)
-spam2(op_and_          , PyNumber_And)
-spam2(op_xor           , PyNumber_Xor)
-spam2(op_or_           , PyNumber_Or)
-spam2(op_iadd          , PyNumber_InPlaceAdd)
-spam2(op_isub          , PyNumber_InPlaceSubtract)
-spam2(op_imul          , PyNumber_InPlaceMultiply)
-spam2(op_imatmul       , PyNumber_InPlaceMatrixMultiply)
-spam2(op_ifloordiv     , PyNumber_InPlaceFloorDivide)
-spam2(op_itruediv      , PyNumber_InPlaceTrueDivide)
-spam2(op_imod          , PyNumber_InPlaceRemainder)
-spam2(op_ilshift       , PyNumber_InPlaceLshift)
-spam2(op_irshift       , PyNumber_InPlaceRshift)
-spam2(op_iand          , PyNumber_InPlaceAnd)
-spam2(op_ixor          , PyNumber_InPlaceXor)
-spam2(op_ior           , PyNumber_InPlaceOr)
-spam2(op_concat        , PySequence_Concat)
-spam2(op_iconcat       , PySequence_InPlaceConcat)
-spami2b(op_contains     , PySequence_Contains)
-spamn2(indexOf         , PySequence_Index)
-spamn2(countOf         , PySequence_Count)
-spam2(op_getitem       , PyObject_GetItem)
-spam2n(op_delitem       , PyObject_DelItem)
-spam3n(op_setitem      , PyObject_SetItem)
-spamrc(op_lt           , Py_LT)
-spamrc(op_le           , Py_LE)
-spamrc(op_eq           , Py_EQ)
-spamrc(op_ne           , Py_NE)
-spamrc(op_gt           , Py_GT)
-spamrc(op_ge           , Py_GE)
-
-static PyObject*
-op_pow(PyObject *s, PyObject *a)
+static int
+_operator_truth_impl(PyModuleDef *module, PyObject *a)
+/*[clinic end generated code: output=ea2eaf3ec6b75529 input=bc74a4cd90235875]*/
 {
-    PyObject *a1, *a2;
-    if (PyArg_UnpackTuple(a,"pow", 2, 2, &a1, &a2))
-        return PyNumber_Power(a1, a2, Py_None);
-    return NULL;
+    return PyObject_IsTrue(a);
 }
 
-static PyObject*
-op_ipow(PyObject *s, PyObject *a)
+/*[clinic input]
+_operator.add
+
+    a: object
+    b: object
+    /
+
+Same as a + b.
+[clinic start generated code]*/
+
+static PyObject *
+_operator_add_impl(PyModuleDef *module, PyObject *a, PyObject *b)
+/*[clinic end generated code: output=131d93208412e1fa input=5efe3bff856ac215]*/
 {
-    PyObject *a1, *a2;
-    if (PyArg_UnpackTuple(a,"ipow", 2, 2, &a1, &a2))
-        return PyNumber_InPlacePower(a1, a2, Py_None);
-    return NULL;
+    return PyNumber_Add(a, b);
 }
 
+/*[clinic input]
+_operator.sub = _operator.add
+
+Same as a - b.
+[clinic start generated code]*/
+
 static PyObject *
-op_index(PyObject *s, PyObject *a)
+_operator_sub_impl(PyModuleDef *module, PyObject *a, PyObject *b)
+/*[clinic end generated code: output=dcb1bb6ed4363f20 input=6494c6b100b8e795]*/
+{
+    return PyNumber_Subtract(a, b);
+}
+
+/*[clinic input]
+_operator.mul = _operator.add
+
+Same as a * b.
+[clinic start generated code]*/
+
+static PyObject *
+_operator_mul_impl(PyModuleDef *module, PyObject *a, PyObject *b)
+/*[clinic end generated code: output=60066b8a571fddb9 input=2368615b4358b70d]*/
+{
+    return PyNumber_Multiply(a, b);
+}
+
+/*[clinic input]
+_operator.matmul = _operator.add
+
+Same as a @ b.
+[clinic start generated code]*/
+
+static PyObject *
+_operator_matmul_impl(PyModuleDef *module, PyObject *a, PyObject *b)
+/*[clinic end generated code: output=1a858b9c9f5be5a0 input=9ab304e37fb42dd4]*/
+{
+    return PyNumber_MatrixMultiply(a, b);
+}
+
+/*[clinic input]
+_operator.floordiv = _operator.add
+
+Same as a // b.
+[clinic start generated code]*/
+
+static PyObject *
+_operator_floordiv_impl(PyModuleDef *module, PyObject *a, PyObject *b)
+/*[clinic end generated code: output=7a572a031549cc71 input=bb2e88ba446c612c]*/
+{
+    return PyNumber_FloorDivide(a, b);
+}
+
+/*[clinic input]
+_operator.truediv = _operator.add
+
+Same as a / b.
+[clinic start generated code]*/
+
+static PyObject *
+_operator_truediv_impl(PyModuleDef *module, PyObject *a, PyObject *b)
+/*[clinic end generated code: output=abf61b84e27c50a4 input=ecbb947673f4eb1f]*/
+{
+    return PyNumber_TrueDivide(a, b);
+}
+
+/*[clinic input]
+_operator.mod = _operator.add
+
+Same as a % b.
+[clinic start generated code]*/
+
+static PyObject *
+_operator_mod_impl(PyModuleDef *module, PyObject *a, PyObject *b)
+/*[clinic end generated code: output=b267410e8d458001 input=102e19b422342ac1]*/
+{
+    return PyNumber_Remainder(a, b);
+}
+
+/*[clinic input]
+_operator.neg
+
+    a: object
+    /
+
+Same as -a.
+[clinic start generated code]*/
+
+static PyObject *
+_operator_neg(PyModuleDef *module, PyObject *a)
+/*[clinic end generated code: output=f7ca16815c9e6445 input=84f09bdcf27c96ec]*/
+{
+    return PyNumber_Negative(a);
+}
+
+/*[clinic input]
+_operator.pos = _operator.neg
+
+Same as +a.
+[clinic start generated code]*/
+
+static PyObject *
+_operator_pos(PyModuleDef *module, PyObject *a)
+/*[clinic end generated code: output=bdb3fd23bee66563 input=b6445b63fddb8772]*/
+{
+    return PyNumber_Positive(a);
+}
+
+/*[clinic input]
+_operator.abs = _operator.neg
+
+Same as abs(a).
+[clinic start generated code]*/
+
+static PyObject *
+_operator_abs(PyModuleDef *module, PyObject *a)
+/*[clinic end generated code: output=7b08634e1a01043e input=341d07ba86f58039]*/
+{
+    return PyNumber_Absolute(a);
+}
+
+/*[clinic input]
+_operator.inv = _operator.neg
+
+Same as ~a.
+[clinic start generated code]*/
+
+static PyObject *
+_operator_inv(PyModuleDef *module, PyObject *a)
+/*[clinic end generated code: output=61eaa3117783ff06 input=b01a4677739f6eb2]*/
+{
+    return PyNumber_Invert(a);
+}
+
+/*[clinic input]
+_operator.invert = _operator.neg
+
+Same as ~a.
+[clinic start generated code]*/
+
+static PyObject *
+_operator_invert(PyModuleDef *module, PyObject *a)
+/*[clinic end generated code: output=b4e6450a3a4254e4 input=7f2d607176672e55]*/
+{
+    return PyNumber_Invert(a);
+}
+
+/*[clinic input]
+_operator.lshift = _operator.add
+
+Same as a << b.
+[clinic start generated code]*/
+
+static PyObject *
+_operator_lshift_impl(PyModuleDef *module, PyObject *a, PyObject *b)
+/*[clinic end generated code: output=233705490d9582c7 input=746e8a160cbbc9eb]*/
+{
+    return PyNumber_Lshift(a, b);
+}
+
+/*[clinic input]
+_operator.rshift = _operator.add
+
+Same as a >> b.
+[clinic start generated code]*/
+
+static PyObject *
+_operator_rshift_impl(PyModuleDef *module, PyObject *a, PyObject *b)
+/*[clinic end generated code: output=0a457efe27c34318 input=d2c85bb5a64504c2]*/
+{
+    return PyNumber_Rshift(a, b);
+}
+
+/*[clinic input]
+_operator.not_ = _operator.truth
+
+Same as not a.
+[clinic start generated code]*/
+
+static int
+_operator_not__impl(PyModuleDef *module, PyObject *a)
+/*[clinic end generated code: output=7b8bc9a6e734de74 input=854156d50804d9b8]*/
+{
+    return PyObject_Not(a);
+}
+
+/*[clinic input]
+_operator.and_ = _operator.add
+
+Same as a & b.
+[clinic start generated code]*/
+
+static PyObject *
+_operator_and__impl(PyModuleDef *module, PyObject *a, PyObject *b)
+/*[clinic end generated code: output=17d8e1a3ad2b314a input=4f3057c90ec4c99f]*/
+{
+    return PyNumber_And(a, b);
+}
+
+/*[clinic input]
+_operator.xor = _operator.add
+
+Same as a ^ b.
+[clinic start generated code]*/
+
+static PyObject *
+_operator_xor_impl(PyModuleDef *module, PyObject *a, PyObject *b)
+/*[clinic end generated code: output=0dff742e6fc7bfc9 input=3c5cfa7253d808dd]*/
+{
+    return PyNumber_Xor(a, b);
+}
+
+/*[clinic input]
+_operator.or_ = _operator.add
+
+Same as a | b.
+[clinic start generated code]*/
+
+static PyObject *
+_operator_or__impl(PyModuleDef *module, PyObject *a, PyObject *b)
+/*[clinic end generated code: output=dcd5db98b700f6a3 input=b40c6c44f7c79c09]*/
+{
+    return PyNumber_Or(a, b);
+}
+
+/*[clinic input]
+_operator.iadd = _operator.add
+
+Same as a += b.
+[clinic start generated code]*/
+
+static PyObject *
+_operator_iadd_impl(PyModuleDef *module, PyObject *a, PyObject *b)
+/*[clinic end generated code: output=741dbb10d9212c42 input=d22a91c07ac69227]*/
+{
+    return PyNumber_InPlaceAdd(a, b);
+}
+
+/*[clinic input]
+_operator.isub = _operator.add
+
+Same as a -= b.
+[clinic start generated code]*/
+
+static PyObject *
+_operator_isub_impl(PyModuleDef *module, PyObject *a, PyObject *b)
+/*[clinic end generated code: output=32a8a184d6ded939 input=4591b00d0a0ccafd]*/
+{
+    return PyNumber_InPlaceSubtract(a, b);
+}
+
+/*[clinic input]
+_operator.imul = _operator.add
+
+Same as a *= b.
+[clinic start generated code]*/
+
+static PyObject *
+_operator_imul_impl(PyModuleDef *module, PyObject *a, PyObject *b)
+/*[clinic end generated code: output=7e5b1cc3beebc38f input=0e01fb8631e1b76f]*/
+{
+    return PyNumber_InPlaceMultiply(a, b);
+}
+
+/*[clinic input]
+_operator.imatmul = _operator.add
+
+Same as a @= b.
+[clinic start generated code]*/
+
+static PyObject *
+_operator_imatmul_impl(PyModuleDef *module, PyObject *a, PyObject *b)
+/*[clinic end generated code: output=20d8250f253515ef input=bb614026372cd542]*/
+{
+    return PyNumber_InPlaceMatrixMultiply(a, b);
+}
+
+/*[clinic input]
+_operator.ifloordiv = _operator.add
+
+Same as a //= b.
+[clinic start generated code]*/
+
+static PyObject *
+_operator_ifloordiv_impl(PyModuleDef *module, PyObject *a, PyObject *b)
+/*[clinic end generated code: output=ce07c3b04ea70ff8 input=9df3b5021cff4ca1]*/
+{
+    return PyNumber_InPlaceFloorDivide(a, b);
+}
+
+/*[clinic input]
+_operator.itruediv = _operator.add
+
+Same as a /= b.
+[clinic start generated code]*/
+
+static PyObject *
+_operator_itruediv_impl(PyModuleDef *module, PyObject *a, PyObject *b)
+/*[clinic end generated code: output=08e09a074330a18a input=9a1ee01608f5f590]*/
+{
+    return PyNumber_InPlaceTrueDivide(a, b);
+}
+
+/*[clinic input]
+_operator.imod = _operator.add
+
+Same as a %= b.
+[clinic start generated code]*/
+
+static PyObject *
+_operator_imod_impl(PyModuleDef *module, PyObject *a, PyObject *b)
+/*[clinic end generated code: output=001b49272debf2dc input=d0c384a3ce38e1dd]*/
+{
+    return PyNumber_InPlaceRemainder(a, b);
+}
+
+/*[clinic input]
+_operator.ilshift = _operator.add
+
+Same as a <<= b.
+[clinic start generated code]*/
+
+static PyObject *
+_operator_ilshift_impl(PyModuleDef *module, PyObject *a, PyObject *b)
+/*[clinic end generated code: output=b05d441220d12f80 input=e21b6b310f54572e]*/
+{
+    return PyNumber_InPlaceLshift(a, b);
+}
+
+/*[clinic input]
+_operator.irshift = _operator.add
+
+Same as a >>= b.
+[clinic start generated code]*/
+
+static PyObject *
+_operator_irshift_impl(PyModuleDef *module, PyObject *a, PyObject *b)
+/*[clinic end generated code: output=41204a5a3db1a0ea input=6778dbd0f6e1ec16]*/
+{
+    return PyNumber_InPlaceRshift(a, b);
+}
+
+/*[clinic input]
+_operator.iand = _operator.add
+
+Same as a &= b.
+[clinic start generated code]*/
+
+static PyObject *
+_operator_iand_impl(PyModuleDef *module, PyObject *a, PyObject *b)
+/*[clinic end generated code: output=f661e67c792052c6 input=71dfd8e70c156a7b]*/
+{
+    return PyNumber_InPlaceAnd(a, b);
+}
+
+/*[clinic input]
+_operator.ixor = _operator.add
+
+Same as a ^= b.
+[clinic start generated code]*/
+
+static PyObject *
+_operator_ixor_impl(PyModuleDef *module, PyObject *a, PyObject *b)
+/*[clinic end generated code: output=0afbd9c14c8dc8e4 input=695c32bec0604d86]*/
+{
+    return PyNumber_InPlaceXor(a, b);
+}
+
+/*[clinic input]
+_operator.ior = _operator.add
+
+Same as a |= b.
+[clinic start generated code]*/
+
+static PyObject *
+_operator_ior_impl(PyModuleDef *module, PyObject *a, PyObject *b)
+/*[clinic end generated code: output=d7fc88b85ea88cb4 input=8f01d03eda9920cf]*/
+{
+    return PyNumber_InPlaceOr(a, b);
+}
+
+/*[clinic input]
+_operator.concat = _operator.add
+
+Same as a + b, for a and b sequences.
+[clinic start generated code]*/
+
+static PyObject *
+_operator_concat_impl(PyModuleDef *module, PyObject *a, PyObject *b)
+/*[clinic end generated code: output=682ada2e2c97e6f7 input=8544ccd5341a3658]*/
+{
+    return PySequence_Concat(a, b);
+}
+
+/*[clinic input]
+_operator.iconcat = _operator.add
+
+Same as a += b, for a and b sequences.
+[clinic start generated code]*/
+
+static PyObject *
+_operator_iconcat_impl(PyModuleDef *module, PyObject *a, PyObject *b)
+/*[clinic end generated code: output=dcecb7a23aec8103 input=8f5fe5722fcd837e]*/
+{
+    return PySequence_InPlaceConcat(a, b);
+}
+
+/*[clinic input]
+_operator.contains -> bool
+
+    a: object
+    b: object
+    /
+
+Same as b in a (note reversed operands).
+[clinic start generated code]*/
+
+static int
+_operator_contains_impl(PyModuleDef *module, PyObject *a, PyObject *b)
+/*[clinic end generated code: output=03ff662c89ca87a9 input=9122a69b505fde13]*/
+{
+    return PySequence_Contains(a, b);
+}
+
+/*[clinic input]
+_operator.indexOf -> Py_ssize_t
+
+    a: object
+    b: object
+    /
+
+Return the first index of b in a.
+[clinic start generated code]*/
+
+static Py_ssize_t
+_operator_indexOf_impl(PyModuleDef *module, PyObject *a, PyObject *b)
+/*[clinic end generated code: output=26d42f4977f49af9 input=8be2e43b6a6fffe3]*/
+{
+    return PySequence_Index(a, b);
+}
+
+/*[clinic input]
+_operator.countOf = _operator.indexOf
+
+Return the number of times b occurs in a.
+[clinic start generated code]*/
+
+static Py_ssize_t
+_operator_countOf_impl(PyModuleDef *module, PyObject *a, PyObject *b)
+/*[clinic end generated code: output=f5299ebb9551469d input=0c3a2656add252db]*/
+{
+    return PySequence_Count(a, b);
+}
+
+/*[clinic input]
+_operator.getitem
+
+    a: object
+    b: object
+    /
+
+Same as a[b].
+[clinic start generated code]*/
+
+static PyObject *
+_operator_getitem_impl(PyModuleDef *module, PyObject *a, PyObject *b)
+/*[clinic end generated code: output=21b544623d2705ba input=6682797320e48845]*/
+{
+    return PyObject_GetItem(a, b);
+}
+
+/*[clinic input]
+_operator.setitem
+
+    a: object
+    b: object
+    c: object
+    /
+
+Same as a[b] = c.
+[clinic start generated code]*/
+
+static PyObject *
+_operator_setitem_impl(PyModuleDef *module, PyObject *a, PyObject *b,
+                       PyObject *c)
+/*[clinic end generated code: output=76ff744d3a51fe1d input=ceaf453c4d3a58df]*/
+{
+    if (-1 == PyObject_SetItem(a, b, c))
+        return NULL;
+    Py_RETURN_NONE;
+}
+
+/*[clinic input]
+_operator.delitem
+
+    a: object
+    b: object
+    /
+
+Same as del a[b].
+[clinic start generated code]*/
+
+static PyObject *
+_operator_delitem_impl(PyModuleDef *module, PyObject *a, PyObject *b)
+/*[clinic end generated code: output=3a7f147fe13aa4a7 input=65ddc43b62bfad40]*/
+{
+    if (-1 == PyObject_DelItem(a, b))
+        return NULL;
+    Py_RETURN_NONE;
+}
+
+/*[clinic input]
+_operator.lt
+
+    a: object
+    b: object
+    /
+
+Same as a < b.
+[clinic start generated code]*/
+
+static PyObject *
+_operator_lt_impl(PyModuleDef *module, PyObject *a, PyObject *b)
+/*[clinic end generated code: output=a2bfb71355379293 input=bf1c3b0ccb0855ae]*/
+{
+    return PyObject_RichCompare(a, b, Py_LT);
+}
+
+/*[clinic input]
+_operator.le = _operator.lt
+
+Same as a <= b.
+[clinic start generated code]*/
+
+static PyObject *
+_operator_le_impl(PyModuleDef *module, PyObject *a, PyObject *b)
+/*[clinic end generated code: output=fff0c983ab2d4032 input=f5400032ccbf005d]*/
+{
+    return PyObject_RichCompare(a, b, Py_LE);
+}
+
+/*[clinic input]
+_operator.eq = _operator.lt
+
+Same as a == b.
+[clinic start generated code]*/
+
+static PyObject *
+_operator_eq_impl(PyModuleDef *module, PyObject *a, PyObject *b)
+/*[clinic end generated code: output=45bc057fc8895ca9 input=4aa255da787c4e02]*/
+{
+    return PyObject_RichCompare(a, b, Py_EQ);
+}
+
+/*[clinic input]
+_operator.ne = _operator.lt
+
+Same as a != b.
+[clinic start generated code]*/
+
+static PyObject *
+_operator_ne_impl(PyModuleDef *module, PyObject *a, PyObject *b)
+/*[clinic end generated code: output=3fa2e90e0594d5de input=d5d688f0f9161c0a]*/
+{
+    return PyObject_RichCompare(a, b, Py_NE);
+}
+
+/*[clinic input]
+_operator.gt = _operator.lt
+
+Same as a > b.
+[clinic start generated code]*/
+
+static PyObject *
+_operator_gt_impl(PyModuleDef *module, PyObject *a, PyObject *b)
+/*[clinic end generated code: output=dbfaaa3de757eddb input=4b5348d0380f73d3]*/
+{
+    return PyObject_RichCompare(a, b, Py_GT);
+}
+
+/*[clinic input]
+_operator.ge = _operator.lt
+
+Same as a >= b.
+[clinic start generated code]*/
+
+static PyObject *
+_operator_ge_impl(PyModuleDef *module, PyObject *a, PyObject *b)
+/*[clinic end generated code: output=b47508997593279d input=917a4333eed34392]*/
+{
+    return PyObject_RichCompare(a, b, Py_GE);
+}
+
+/*[clinic input]
+_operator.pow = _operator.add
+
+Same as a ** b.
+[clinic start generated code]*/
+
+static PyObject *
+_operator_pow_impl(PyModuleDef *module, PyObject *a, PyObject *b)
+/*[clinic end generated code: output=2836618206ae8736 input=690b40f097ab1637]*/
+{
+    return PyNumber_Power(a, b, Py_None);
+}
+
+/*[clinic input]
+_operator.ipow = _operator.add
+
+Same as a **= b.
+[clinic start generated code]*/
+
+static PyObject *
+_operator_ipow_impl(PyModuleDef *module, PyObject *a, PyObject *b)
+/*[clinic end generated code: output=39c9792796907801 input=f00623899d07499a]*/
+{
+    return PyNumber_InPlacePower(a, b, Py_None);
+}
+
+/*[clinic input]
+_operator.index
+
+    a: object
+    /
+
+Same as a.__index__()
+[clinic start generated code]*/
+
+static PyObject *
+_operator_index(PyModuleDef *module, PyObject *a)
+/*[clinic end generated code: output=8b194c72aa287c74 input=6f54d50ea64a579c]*/
 {
     return PyNumber_Index(a);
 }
 
-static PyObject*
-is_(PyObject *s, PyObject *a)
+/*[clinic input]
+_operator.is_
+
+    a: object
+    b: object
+    /
+
+Same as a is b.
+[clinic start generated code]*/
+
+static PyObject *
+_operator_is__impl(PyModuleDef *module, PyObject *a, PyObject *b)
+/*[clinic end generated code: output=bc1fd7357f64ff22 input=9ee971d5649695e7]*/
 {
-    PyObject *a1, *a2, *result = NULL;
-    if (PyArg_UnpackTuple(a,"is_", 2, 2, &a1, &a2)) {
-        result = (a1 == a2) ? Py_True : Py_False;
-        Py_INCREF(result);
-    }
+    PyObject *result;
+    result = (a == b) ? Py_True : Py_False;
+    Py_INCREF(result);
     return result;
 }
 
-static PyObject*
-is_not(PyObject *s, PyObject *a)
+/*[clinic input]
+_operator.is_not = _operator.is_
+
+Same as a is not b.
+[clinic start generated code]*/
+
+static PyObject *
+_operator_is_not_impl(PyModuleDef *module, PyObject *a, PyObject *b)
+/*[clinic end generated code: output=a350951577b7fb7d input=c3fdfbc79e45c10e]*/
 {
-    PyObject *a1, *a2, *result = NULL;
-    if (PyArg_UnpackTuple(a,"is_not", 2, 2, &a1, &a2)) {
-        result = (a1 != a2) ? Py_True : Py_False;
-        Py_INCREF(result);
-    }
+    PyObject *result;
+    result = (a != b) ? Py_True : Py_False;
+    Py_INCREF(result);
     return result;
 }
 
-#undef spam1
-#undef spam2
-#undef spam1o
-#undef spam1o
-
 /* compare_digest **********************************************************/
 
 /*
@@ -210,23 +769,29 @@
     return (result == 0);
 }
 
-PyDoc_STRVAR(length_hint__doc__,
-"length_hint(obj, default=0) -> int\n"
-"Return an estimate of the number of items in obj.\n"
-"This is useful for presizing containers when building from an\n"
-"iterable.\n"
-"\n"
-"If the object supports len(), the result will be\n"
-"exact. Otherwise, it may over- or under-estimate by an\n"
-"arbitrary amount. The result will be an integer >= 0.");
+/*[clinic input]
+_operator.length_hint
 
-static PyObject *length_hint(PyObject *self, PyObject *args)
+    obj: object
+    default as defaultvalue: Py_ssize_t = 0
+    /
+
+Return an estimate of the number of items in obj.
+
+This is useful for presizing containers when building from an iterable.
+
+If the object supports len(), the result will be exact.
+Otherwise, it may over- or under-estimate by an arbitrary amount.
+The result will be an integer >= 0.
+[clinic start generated code]*/
+
+static PyObject *
+_operator_length_hint_impl(PyModuleDef *module, PyObject *obj,
+                           Py_ssize_t defaultvalue)
+/*[clinic end generated code: output=76d14da85693e774 input=8facd190d3375340]*/
 {
-    PyObject *obj;
-    Py_ssize_t defaultvalue = 0, res;
-    if (!PyArg_ParseTuple(args, "O|n:length_hint", &obj, &defaultvalue)) {
-        return NULL;
-    }
+    Py_ssize_t res;
+
     res = PyObject_LengthHint(obj, defaultvalue);
     if (res == -1 && PyErr_Occurred()) {
         return NULL;
@@ -234,29 +799,31 @@
     return PyLong_FromSsize_t(res);
 }
 
+/*[clinic input]
+_operator._compare_digest
 
-PyDoc_STRVAR(compare_digest__doc__,
-"compare_digest(a, b) -> bool\n"
-"\n"
-"Return 'a == b'.  This function uses an approach designed to prevent\n"
-"timing analysis, making it appropriate for cryptography.\n"
-"a and b must both be of the same type: either str (ASCII only),\n"
-"or any bytes-like object.\n"
-"\n"
-"Note: If a and b are of different lengths, or if an error occurs,\n"
-"a timing attack could theoretically reveal information about the\n"
-"types and lengths of a and b--but not their values.\n");
+    a: object
+    b: object
 
-static PyObject*
-compare_digest(PyObject *self, PyObject *args)
+Return 'a == b'.
+
+This function uses an approach designed to prevent
+timing analysis, making it appropriate for cryptography.
+
+a and b must both be of the same type: either str (ASCII only),
+or any bytes-like object.
+
+Note: If a and b are of different lengths, or if an error occurs,
+a timing attack could theoretically reveal information about the
+types and lengths of a and b--but not their values.
+[clinic start generated code]*/
+
+static PyObject *
+_operator__compare_digest_impl(PyModuleDef *module, PyObject *a, PyObject *b)
+/*[clinic end generated code: output=41eec2edbbec3ed5 input=b13a34c8231eb8b2]*/
 {
-    PyObject *a, *b;
     int rc;
 
-    if (!PyArg_ParseTuple(args, "OO:compare_digest", &a, &b)) {
-        return NULL;
-    }
-
     /* ASCII unicode string */
     if(PyUnicode_Check(a) && PyUnicode_Check(b)) {
         if (PyUnicode_READY(a) == -1 || PyUnicode_READY(b) == -1) {
@@ -323,78 +890,60 @@
 
 /* operator methods **********************************************************/
 
-#define spam1(OP,DOC) {#OP, OP, METH_VARARGS, PyDoc_STR(DOC)},
-#define spam2(OP,DOC) {#OP, op_##OP, METH_VARARGS, PyDoc_STR(DOC)},
-#define spam1o(OP,DOC) {#OP, OP, METH_O, PyDoc_STR(DOC)},
-#define spam2o(OP,DOC) {#OP, op_##OP, METH_O, PyDoc_STR(DOC)},
-
 static struct PyMethodDef operator_methods[] = {
 
-spam1o(truth,
- "truth(a) -- Return True if a is true, False otherwise.")
-spam2(contains,
- "contains(a, b) -- Same as b in a (note reversed operands).")
-spam1(indexOf,
- "indexOf(a, b) -- Return the first index of b in a.")
-spam1(countOf,
- "countOf(a, b) -- Return the number of times b occurs in a.")
-
-spam1(is_, "is_(a, b) -- Same as a is b.")
-spam1(is_not, "is_not(a, b) -- Same as a is not b.")
-spam2o(index, "index(a) -- Same as a.__index__()")
-spam2(add, "add(a, b) -- Same as a + b.")
-spam2(sub, "sub(a, b) -- Same as a - b.")
-spam2(mul, "mul(a, b) -- Same as a * b.")
-spam2(matmul, "matmul(a, b) -- Same as a @ b.")
-spam2(floordiv, "floordiv(a, b) -- Same as a // b.")
-spam2(truediv, "truediv(a, b) -- Same as a / b.")
-spam2(mod, "mod(a, b) -- Same as a % b.")
-spam2o(neg, "neg(a) -- Same as -a.")
-spam2o(pos, "pos(a) -- Same as +a.")
-spam2o(abs, "abs(a) -- Same as abs(a).")
-spam2o(inv, "inv(a) -- Same as ~a.")
-spam2o(invert, "invert(a) -- Same as ~a.")
-spam2(lshift, "lshift(a, b) -- Same as a << b.")
-spam2(rshift, "rshift(a, b) -- Same as a >> b.")
-spam2o(not_, "not_(a) -- Same as not a.")
-spam2(and_, "and_(a, b) -- Same as a & b.")
-spam2(xor, "xor(a, b) -- Same as a ^ b.")
-spam2(or_, "or_(a, b) -- Same as a | b.")
-spam2(iadd, "a = iadd(a, b) -- Same as a += b.")
-spam2(isub, "a = isub(a, b) -- Same as a -= b.")
-spam2(imul, "a = imul(a, b) -- Same as a *= b.")
-spam2(imatmul, "a = imatmul(a, b) -- Same as a @= b.")
-spam2(ifloordiv, "a = ifloordiv(a, b) -- Same as a //= b.")
-spam2(itruediv, "a = itruediv(a, b) -- Same as a /= b")
-spam2(imod, "a = imod(a, b) -- Same as a %= b.")
-spam2(ilshift, "a = ilshift(a, b) -- Same as a <<= b.")
-spam2(irshift, "a = irshift(a, b) -- Same as a >>= b.")
-spam2(iand, "a = iand(a, b) -- Same as a &= b.")
-spam2(ixor, "a = ixor(a, b) -- Same as a ^= b.")
-spam2(ior, "a = ior(a, b) -- Same as a |= b.")
-spam2(concat,
- "concat(a, b) -- Same as a + b, for a and b sequences.")
-spam2(iconcat,
- "a = iconcat(a, b) -- Same as a += b, for a and b sequences.")
-spam2(getitem,
- "getitem(a, b) -- Same as a[b].")
-spam2(setitem,
- "setitem(a, b, c) -- Same as a[b] = c.")
-spam2(delitem,
- "delitem(a, b) -- Same as del a[b].")
-spam2(pow, "pow(a, b) -- Same as a ** b.")
-spam2(ipow, "a = ipow(a, b) -- Same as a **= b.")
-spam2(lt, "lt(a, b) -- Same as a<b.")
-spam2(le, "le(a, b) -- Same as a<=b.")
-spam2(eq, "eq(a, b) -- Same as a==b.")
-spam2(ne, "ne(a, b) -- Same as a!=b.")
-spam2(gt, "gt(a, b) -- Same as a>b.")
-spam2(ge, "ge(a, b) -- Same as a>=b.")
-
-    {"_compare_digest", (PyCFunction)compare_digest, METH_VARARGS,
-     compare_digest__doc__},
-     {"length_hint", (PyCFunction)length_hint, METH_VARARGS,
-     length_hint__doc__},
+    _OPERATOR_TRUTH_METHODDEF
+    _OPERATOR_CONTAINS_METHODDEF
+    _OPERATOR_INDEXOF_METHODDEF
+    _OPERATOR_COUNTOF_METHODDEF
+    _OPERATOR_IS__METHODDEF
+    _OPERATOR_IS_NOT_METHODDEF
+    _OPERATOR_INDEX_METHODDEF
+    _OPERATOR_ADD_METHODDEF
+    _OPERATOR_SUB_METHODDEF
+    _OPERATOR_MUL_METHODDEF
+    _OPERATOR_MATMUL_METHODDEF
+    _OPERATOR_FLOORDIV_METHODDEF
+    _OPERATOR_TRUEDIV_METHODDEF
+    _OPERATOR_MOD_METHODDEF
+    _OPERATOR_NEG_METHODDEF
+    _OPERATOR_POS_METHODDEF
+    _OPERATOR_ABS_METHODDEF
+    _OPERATOR_INV_METHODDEF
+    _OPERATOR_INVERT_METHODDEF
+    _OPERATOR_LSHIFT_METHODDEF
+    _OPERATOR_RSHIFT_METHODDEF
+    _OPERATOR_NOT__METHODDEF
+    _OPERATOR_AND__METHODDEF
+    _OPERATOR_XOR_METHODDEF
+    _OPERATOR_OR__METHODDEF
+    _OPERATOR_IADD_METHODDEF
+    _OPERATOR_ISUB_METHODDEF
+    _OPERATOR_IMUL_METHODDEF
+    _OPERATOR_IMATMUL_METHODDEF
+    _OPERATOR_IFLOORDIV_METHODDEF
+    _OPERATOR_ITRUEDIV_METHODDEF
+    _OPERATOR_IMOD_METHODDEF
+    _OPERATOR_ILSHIFT_METHODDEF
+    _OPERATOR_IRSHIFT_METHODDEF
+    _OPERATOR_IAND_METHODDEF
+    _OPERATOR_IXOR_METHODDEF
+    _OPERATOR_IOR_METHODDEF
+    _OPERATOR_CONCAT_METHODDEF
+    _OPERATOR_ICONCAT_METHODDEF
+    _OPERATOR_GETITEM_METHODDEF
+    _OPERATOR_SETITEM_METHODDEF
+    _OPERATOR_DELITEM_METHODDEF
+    _OPERATOR_POW_METHODDEF
+    _OPERATOR_IPOW_METHODDEF
+    _OPERATOR_LT_METHODDEF
+    _OPERATOR_LE_METHODDEF
+    _OPERATOR_EQ_METHODDEF
+    _OPERATOR_NE_METHODDEF
+    _OPERATOR_GT_METHODDEF
+    _OPERATOR_GE_METHODDEF
+    _OPERATOR__COMPARE_DIGEST_METHODDEF
+    _OPERATOR_LENGTH_HINT_METHODDEF
     {NULL,              NULL}           /* sentinel */
 
 };
@@ -409,6 +958,7 @@
 
 static PyTypeObject itemgetter_type;
 
+/* AC 3.5: treats first argument as an iterable, otherwise uses *args */
 static PyObject *
 itemgetter_new(PyTypeObject *type, PyObject *args, PyObject *kwds)
 {
@@ -581,6 +1131,7 @@
 
 static PyTypeObject attrgetter_type;
 
+/* AC 3.5: treats first argument as an iterable, otherwise uses *args */
 static PyObject *
 attrgetter_new(PyTypeObject *type, PyObject *args, PyObject *kwds)
 {
@@ -923,6 +1474,7 @@
 
 static PyTypeObject methodcaller_type;
 
+/* AC 3.5: variable number of arguments, not currently support by AC */
 static PyObject *
 methodcaller_new(PyTypeObject *type, PyObject *args, PyObject *kwds)
 {
diff --git a/Modules/clinic/_operator.c.h b/Modules/clinic/_operator.c.h
new file mode 100644
--- /dev/null
+++ b/Modules/clinic/_operator.c.h
@@ -0,0 +1,1418 @@
+/*[clinic input]
+preserve
+[clinic start generated code]*/
+
+PyDoc_STRVAR(_operator_truth__doc__,
+"truth($module, a, /)\n"
+"--\n"
+"\n"
+"Return True if a is true, False otherwise.");
+
+#define _OPERATOR_TRUTH_METHODDEF    \
+    {"truth", (PyCFunction)_operator_truth, METH_O, _operator_truth__doc__},
+
+static int
+_operator_truth_impl(PyModuleDef *module, PyObject *a);
+
+static PyObject *
+_operator_truth(PyModuleDef *module, PyObject *a)
+{
+    PyObject *return_value = NULL;
+    int _return_value;
+
+    _return_value = _operator_truth_impl(module, a);
+    if ((_return_value == -1) && PyErr_Occurred())
+        goto exit;
+    return_value = PyBool_FromLong((long)_return_value);
+
+exit:
+    return return_value;
+}
+
+PyDoc_STRVAR(_operator_add__doc__,
+"add($module, a, b, /)\n"
+"--\n"
+"\n"
+"Same as a + b.");
+
+#define _OPERATOR_ADD_METHODDEF    \
+    {"add", (PyCFunction)_operator_add, METH_VARARGS, _operator_add__doc__},
+
+static PyObject *
+_operator_add_impl(PyModuleDef *module, PyObject *a, PyObject *b);
+
+static PyObject *
+_operator_add(PyModuleDef *module, PyObject *args)
+{
+    PyObject *return_value = NULL;
+    PyObject *a;
+    PyObject *b;
+
+    if (!PyArg_UnpackTuple(args, "add",
+        2, 2,
+        &a, &b))
+        goto exit;
+    return_value = _operator_add_impl(module, a, b);
+
+exit:
+    return return_value;
+}
+
+PyDoc_STRVAR(_operator_sub__doc__,
+"sub($module, a, b, /)\n"
+"--\n"
+"\n"
+"Same as a - b.");
+
+#define _OPERATOR_SUB_METHODDEF    \
+    {"sub", (PyCFunction)_operator_sub, METH_VARARGS, _operator_sub__doc__},
+
+static PyObject *
+_operator_sub_impl(PyModuleDef *module, PyObject *a, PyObject *b);
+
+static PyObject *
+_operator_sub(PyModuleDef *module, PyObject *args)
+{
+    PyObject *return_value = NULL;
+    PyObject *a;
+    PyObject *b;
+
+    if (!PyArg_UnpackTuple(args, "sub",
+        2, 2,
+        &a, &b))
+        goto exit;
+    return_value = _operator_sub_impl(module, a, b);
+
+exit:
+    return return_value;
+}
+
+PyDoc_STRVAR(_operator_mul__doc__,
+"mul($module, a, b, /)\n"
+"--\n"
+"\n"
+"Same as a * b.");
+
+#define _OPERATOR_MUL_METHODDEF    \
+    {"mul", (PyCFunction)_operator_mul, METH_VARARGS, _operator_mul__doc__},
+
+static PyObject *
+_operator_mul_impl(PyModuleDef *module, PyObject *a, PyObject *b);
+
+static PyObject *
+_operator_mul(PyModuleDef *module, PyObject *args)
+{
+    PyObject *return_value = NULL;
+    PyObject *a;
+    PyObject *b;
+
+    if (!PyArg_UnpackTuple(args, "mul",
+        2, 2,
+        &a, &b))
+        goto exit;
+    return_value = _operator_mul_impl(module, a, b);
+
+exit:
+    return return_value;
+}
+
+PyDoc_STRVAR(_operator_matmul__doc__,
+"matmul($module, a, b, /)\n"
+"--\n"
+"\n"
+"Same as a @ b.");
+
+#define _OPERATOR_MATMUL_METHODDEF    \
+    {"matmul", (PyCFunction)_operator_matmul, METH_VARARGS, _operator_matmul__doc__},
+
+static PyObject *
+_operator_matmul_impl(PyModuleDef *module, PyObject *a, PyObject *b);
+
+static PyObject *
+_operator_matmul(PyModuleDef *module, PyObject *args)
+{
+    PyObject *return_value = NULL;
+    PyObject *a;
+    PyObject *b;
+
+    if (!PyArg_UnpackTuple(args, "matmul",
+        2, 2,
+        &a, &b))
+        goto exit;
+    return_value = _operator_matmul_impl(module, a, b);
+
+exit:
+    return return_value;
+}
+
+PyDoc_STRVAR(_operator_floordiv__doc__,
+"floordiv($module, a, b, /)\n"
+"--\n"
+"\n"
+"Same as a // b.");
+
+#define _OPERATOR_FLOORDIV_METHODDEF    \
+    {"floordiv", (PyCFunction)_operator_floordiv, METH_VARARGS, _operator_floordiv__doc__},
+
+static PyObject *
+_operator_floordiv_impl(PyModuleDef *module, PyObject *a, PyObject *b);
+
+static PyObject *
+_operator_floordiv(PyModuleDef *module, PyObject *args)
+{
+    PyObject *return_value = NULL;
+    PyObject *a;
+    PyObject *b;
+
+    if (!PyArg_UnpackTuple(args, "floordiv",
+        2, 2,
+        &a, &b))
+        goto exit;
+    return_value = _operator_floordiv_impl(module, a, b);
+
+exit:
+    return return_value;
+}
+
+PyDoc_STRVAR(_operator_truediv__doc__,
+"truediv($module, a, b, /)\n"
+"--\n"
+"\n"
+"Same as a / b.");
+
+#define _OPERATOR_TRUEDIV_METHODDEF    \
+    {"truediv", (PyCFunction)_operator_truediv, METH_VARARGS, _operator_truediv__doc__},
+
+static PyObject *
+_operator_truediv_impl(PyModuleDef *module, PyObject *a, PyObject *b);
+
+static PyObject *
+_operator_truediv(PyModuleDef *module, PyObject *args)
+{
+    PyObject *return_value = NULL;
+    PyObject *a;
+    PyObject *b;
+
+    if (!PyArg_UnpackTuple(args, "truediv",
+        2, 2,
+        &a, &b))
+        goto exit;
+    return_value = _operator_truediv_impl(module, a, b);
+
+exit:
+    return return_value;
+}
+
+PyDoc_STRVAR(_operator_mod__doc__,
+"mod($module, a, b, /)\n"
+"--\n"
+"\n"
+"Same as a % b.");
+
+#define _OPERATOR_MOD_METHODDEF    \
+    {"mod", (PyCFunction)_operator_mod, METH_VARARGS, _operator_mod__doc__},
+
+static PyObject *
+_operator_mod_impl(PyModuleDef *module, PyObject *a, PyObject *b);
+
+static PyObject *
+_operator_mod(PyModuleDef *module, PyObject *args)
+{
+    PyObject *return_value = NULL;
+    PyObject *a;
+    PyObject *b;
+
+    if (!PyArg_UnpackTuple(args, "mod",
+        2, 2,
+        &a, &b))
+        goto exit;
+    return_value = _operator_mod_impl(module, a, b);
+
+exit:
+    return return_value;
+}
+
+PyDoc_STRVAR(_operator_neg__doc__,
+"neg($module, a, /)\n"
+"--\n"
+"\n"
+"Same as -a.");
+
+#define _OPERATOR_NEG_METHODDEF    \
+    {"neg", (PyCFunction)_operator_neg, METH_O, _operator_neg__doc__},
+
+PyDoc_STRVAR(_operator_pos__doc__,
+"pos($module, a, /)\n"
+"--\n"
+"\n"
+"Same as +a.");
+
+#define _OPERATOR_POS_METHODDEF    \
+    {"pos", (PyCFunction)_operator_pos, METH_O, _operator_pos__doc__},
+
+PyDoc_STRVAR(_operator_abs__doc__,
+"abs($module, a, /)\n"
+"--\n"
+"\n"
+"Same as abs(a).");
+
+#define _OPERATOR_ABS_METHODDEF    \
+    {"abs", (PyCFunction)_operator_abs, METH_O, _operator_abs__doc__},
+
+PyDoc_STRVAR(_operator_inv__doc__,
+"inv($module, a, /)\n"
+"--\n"
+"\n"
+"Same as ~a.");
+
+#define _OPERATOR_INV_METHODDEF    \
+    {"inv", (PyCFunction)_operator_inv, METH_O, _operator_inv__doc__},
+
+PyDoc_STRVAR(_operator_invert__doc__,
+"invert($module, a, /)\n"
+"--\n"
+"\n"
+"Same as ~a.");
+
+#define _OPERATOR_INVERT_METHODDEF    \
+    {"invert", (PyCFunction)_operator_invert, METH_O, _operator_invert__doc__},
+
+PyDoc_STRVAR(_operator_lshift__doc__,
+"lshift($module, a, b, /)\n"
+"--\n"
+"\n"
+"Same as a << b.");
+
+#define _OPERATOR_LSHIFT_METHODDEF    \
+    {"lshift", (PyCFunction)_operator_lshift, METH_VARARGS, _operator_lshift__doc__},
+
+static PyObject *
+_operator_lshift_impl(PyModuleDef *module, PyObject *a, PyObject *b);
+
+static PyObject *
+_operator_lshift(PyModuleDef *module, PyObject *args)
+{
+    PyObject *return_value = NULL;
+    PyObject *a;
+    PyObject *b;
+
+    if (!PyArg_UnpackTuple(args, "lshift",
+        2, 2,
+        &a, &b))
+        goto exit;
+    return_value = _operator_lshift_impl(module, a, b);
+
+exit:
+    return return_value;
+}
+
+PyDoc_STRVAR(_operator_rshift__doc__,
+"rshift($module, a, b, /)\n"
+"--\n"
+"\n"
+"Same as a >> b.");
+
+#define _OPERATOR_RSHIFT_METHODDEF    \
+    {"rshift", (PyCFunction)_operator_rshift, METH_VARARGS, _operator_rshift__doc__},
+
+static PyObject *
+_operator_rshift_impl(PyModuleDef *module, PyObject *a, PyObject *b);
+
+static PyObject *
+_operator_rshift(PyModuleDef *module, PyObject *args)
+{
+    PyObject *return_value = NULL;
+    PyObject *a;
+    PyObject *b;
+
+    if (!PyArg_UnpackTuple(args, "rshift",
+        2, 2,
+        &a, &b))
+        goto exit;
+    return_value = _operator_rshift_impl(module, a, b);
+
+exit:
+    return return_value;
+}
+
+PyDoc_STRVAR(_operator_not___doc__,
+"not_($module, a, /)\n"
+"--\n"
+"\n"
+"Same as not a.");
+
+#define _OPERATOR_NOT__METHODDEF    \
+    {"not_", (PyCFunction)_operator_not_, METH_O, _operator_not___doc__},
+
+static int
+_operator_not__impl(PyModuleDef *module, PyObject *a);
+
+static PyObject *
+_operator_not_(PyModuleDef *module, PyObject *a)
+{
+    PyObject *return_value = NULL;
+    int _return_value;
+
+    _return_value = _operator_not__impl(module, a);
+    if ((_return_value == -1) && PyErr_Occurred())
+        goto exit;
+    return_value = PyBool_FromLong((long)_return_value);
+
+exit:
+    return return_value;
+}
+
+PyDoc_STRVAR(_operator_and___doc__,
+"and_($module, a, b, /)\n"
+"--\n"
+"\n"
+"Same as a & b.");
+
+#define _OPERATOR_AND__METHODDEF    \
+    {"and_", (PyCFunction)_operator_and_, METH_VARARGS, _operator_and___doc__},
+
+static PyObject *
+_operator_and__impl(PyModuleDef *module, PyObject *a, PyObject *b);
+
+static PyObject *
+_operator_and_(PyModuleDef *module, PyObject *args)
+{
+    PyObject *return_value = NULL;
+    PyObject *a;
+    PyObject *b;
+
+    if (!PyArg_UnpackTuple(args, "and_",
+        2, 2,
+        &a, &b))
+        goto exit;
+    return_value = _operator_and__impl(module, a, b);
+
+exit:
+    return return_value;
+}
+
+PyDoc_STRVAR(_operator_xor__doc__,
+"xor($module, a, b, /)\n"
+"--\n"
+"\n"
+"Same as a ^ b.");
+
+#define _OPERATOR_XOR_METHODDEF    \
+    {"xor", (PyCFunction)_operator_xor, METH_VARARGS, _operator_xor__doc__},
+
+static PyObject *
+_operator_xor_impl(PyModuleDef *module, PyObject *a, PyObject *b);
+
+static PyObject *
+_operator_xor(PyModuleDef *module, PyObject *args)
+{
+    PyObject *return_value = NULL;
+    PyObject *a;
+    PyObject *b;
+
+    if (!PyArg_UnpackTuple(args, "xor",
+        2, 2,
+        &a, &b))
+        goto exit;
+    return_value = _operator_xor_impl(module, a, b);
+
+exit:
+    return return_value;
+}
+
+PyDoc_STRVAR(_operator_or___doc__,
+"or_($module, a, b, /)\n"
+"--\n"
+"\n"
+"Same as a | b.");
+
+#define _OPERATOR_OR__METHODDEF    \
+    {"or_", (PyCFunction)_operator_or_, METH_VARARGS, _operator_or___doc__},
+
+static PyObject *
+_operator_or__impl(PyModuleDef *module, PyObject *a, PyObject *b);
+
+static PyObject *
+_operator_or_(PyModuleDef *module, PyObject *args)
+{
+    PyObject *return_value = NULL;
+    PyObject *a;
+    PyObject *b;
+
+    if (!PyArg_UnpackTuple(args, "or_",
+        2, 2,
+        &a, &b))
+        goto exit;
+    return_value = _operator_or__impl(module, a, b);
+
+exit:
+    return return_value;
+}
+
+PyDoc_STRVAR(_operator_iadd__doc__,
+"iadd($module, a, b, /)\n"
+"--\n"
+"\n"
+"Same as a += b.");
+
+#define _OPERATOR_IADD_METHODDEF    \
+    {"iadd", (PyCFunction)_operator_iadd, METH_VARARGS, _operator_iadd__doc__},
+
+static PyObject *
+_operator_iadd_impl(PyModuleDef *module, PyObject *a, PyObject *b);
+
+static PyObject *
+_operator_iadd(PyModuleDef *module, PyObject *args)
+{
+    PyObject *return_value = NULL;
+    PyObject *a;
+    PyObject *b;
+
+    if (!PyArg_UnpackTuple(args, "iadd",
+        2, 2,
+        &a, &b))
+        goto exit;
+    return_value = _operator_iadd_impl(module, a, b);
+
+exit:
+    return return_value;
+}
+
+PyDoc_STRVAR(_operator_isub__doc__,
+"isub($module, a, b, /)\n"
+"--\n"
+"\n"
+"Same as a -= b.");
+
+#define _OPERATOR_ISUB_METHODDEF    \
+    {"isub", (PyCFunction)_operator_isub, METH_VARARGS, _operator_isub__doc__},
+
+static PyObject *
+_operator_isub_impl(PyModuleDef *module, PyObject *a, PyObject *b);
+
+static PyObject *
+_operator_isub(PyModuleDef *module, PyObject *args)
+{
+    PyObject *return_value = NULL;
+    PyObject *a;
+    PyObject *b;
+
+    if (!PyArg_UnpackTuple(args, "isub",
+        2, 2,
+        &a, &b))
+        goto exit;
+    return_value = _operator_isub_impl(module, a, b);
+
+exit:
+    return return_value;
+}
+
+PyDoc_STRVAR(_operator_imul__doc__,
+"imul($module, a, b, /)\n"
+"--\n"
+"\n"
+"Same as a *= b.");
+
+#define _OPERATOR_IMUL_METHODDEF    \
+    {"imul", (PyCFunction)_operator_imul, METH_VARARGS, _operator_imul__doc__},
+
+static PyObject *
+_operator_imul_impl(PyModuleDef *module, PyObject *a, PyObject *b);
+
+static PyObject *
+_operator_imul(PyModuleDef *module, PyObject *args)
+{
+    PyObject *return_value = NULL;
+    PyObject *a;
+    PyObject *b;
+
+    if (!PyArg_UnpackTuple(args, "imul",
+        2, 2,
+        &a, &b))
+        goto exit;
+    return_value = _operator_imul_impl(module, a, b);
+
+exit:
+    return return_value;
+}
+
+PyDoc_STRVAR(_operator_imatmul__doc__,
+"imatmul($module, a, b, /)\n"
+"--\n"
+"\n"
+"Same as a @= b.");
+
+#define _OPERATOR_IMATMUL_METHODDEF    \
+    {"imatmul", (PyCFunction)_operator_imatmul, METH_VARARGS, _operator_imatmul__doc__},
+
+static PyObject *
+_operator_imatmul_impl(PyModuleDef *module, PyObject *a, PyObject *b);
+
+static PyObject *
+_operator_imatmul(PyModuleDef *module, PyObject *args)
+{
+    PyObject *return_value = NULL;
+    PyObject *a;
+    PyObject *b;
+
+    if (!PyArg_UnpackTuple(args, "imatmul",
+        2, 2,
+        &a, &b))
+        goto exit;
+    return_value = _operator_imatmul_impl(module, a, b);
+
+exit:
+    return return_value;
+}
+
+PyDoc_STRVAR(_operator_ifloordiv__doc__,
+"ifloordiv($module, a, b, /)\n"
+"--\n"
+"\n"
+"Same as a //= b.");
+
+#define _OPERATOR_IFLOORDIV_METHODDEF    \
+    {"ifloordiv", (PyCFunction)_operator_ifloordiv, METH_VARARGS, _operator_ifloordiv__doc__},
+
+static PyObject *
+_operator_ifloordiv_impl(PyModuleDef *module, PyObject *a, PyObject *b);
+
+static PyObject *
+_operator_ifloordiv(PyModuleDef *module, PyObject *args)
+{
+    PyObject *return_value = NULL;
+    PyObject *a;
+    PyObject *b;
+
+    if (!PyArg_UnpackTuple(args, "ifloordiv",
+        2, 2,
+        &a, &b))
+        goto exit;
+    return_value = _operator_ifloordiv_impl(module, a, b);
+
+exit:
+    return return_value;
+}
+
+PyDoc_STRVAR(_operator_itruediv__doc__,
+"itruediv($module, a, b, /)\n"
+"--\n"
+"\n"
+"Same as a /= b.");
+
+#define _OPERATOR_ITRUEDIV_METHODDEF    \
+    {"itruediv", (PyCFunction)_operator_itruediv, METH_VARARGS, _operator_itruediv__doc__},
+
+static PyObject *
+_operator_itruediv_impl(PyModuleDef *module, PyObject *a, PyObject *b);
+
+static PyObject *
+_operator_itruediv(PyModuleDef *module, PyObject *args)
+{
+    PyObject *return_value = NULL;
+    PyObject *a;
+    PyObject *b;
+
+    if (!PyArg_UnpackTuple(args, "itruediv",
+        2, 2,
+        &a, &b))
+        goto exit;
+    return_value = _operator_itruediv_impl(module, a, b);
+
+exit:
+    return return_value;
+}
+
+PyDoc_STRVAR(_operator_imod__doc__,
+"imod($module, a, b, /)\n"
+"--\n"
+"\n"
+"Same as a %= b.");
+
+#define _OPERATOR_IMOD_METHODDEF    \
+    {"imod", (PyCFunction)_operator_imod, METH_VARARGS, _operator_imod__doc__},
+
+static PyObject *
+_operator_imod_impl(PyModuleDef *module, PyObject *a, PyObject *b);
+
+static PyObject *
+_operator_imod(PyModuleDef *module, PyObject *args)
+{
+    PyObject *return_value = NULL;
+    PyObject *a;
+    PyObject *b;
+
+    if (!PyArg_UnpackTuple(args, "imod",
+        2, 2,
+        &a, &b))
+        goto exit;
+    return_value = _operator_imod_impl(module, a, b);
+
+exit:
+    return return_value;
+}
+
+PyDoc_STRVAR(_operator_ilshift__doc__,
+"ilshift($module, a, b, /)\n"
+"--\n"
+"\n"
+"Same as a <<= b.");
+
+#define _OPERATOR_ILSHIFT_METHODDEF    \
+    {"ilshift", (PyCFunction)_operator_ilshift, METH_VARARGS, _operator_ilshift__doc__},
+
+static PyObject *
+_operator_ilshift_impl(PyModuleDef *module, PyObject *a, PyObject *b);
+
+static PyObject *
+_operator_ilshift(PyModuleDef *module, PyObject *args)
+{
+    PyObject *return_value = NULL;
+    PyObject *a;
+    PyObject *b;
+
+    if (!PyArg_UnpackTuple(args, "ilshift",
+        2, 2,
+        &a, &b))
+        goto exit;
+    return_value = _operator_ilshift_impl(module, a, b);
+
+exit:
+    return return_value;
+}
+
+PyDoc_STRVAR(_operator_irshift__doc__,
+"irshift($module, a, b, /)\n"
+"--\n"
+"\n"
+"Same as a >>= b.");
+
+#define _OPERATOR_IRSHIFT_METHODDEF    \
+    {"irshift", (PyCFunction)_operator_irshift, METH_VARARGS, _operator_irshift__doc__},
+
+static PyObject *
+_operator_irshift_impl(PyModuleDef *module, PyObject *a, PyObject *b);
+
+static PyObject *
+_operator_irshift(PyModuleDef *module, PyObject *args)
+{
+    PyObject *return_value = NULL;
+    PyObject *a;
+    PyObject *b;
+
+    if (!PyArg_UnpackTuple(args, "irshift",
+        2, 2,
+        &a, &b))
+        goto exit;
+    return_value = _operator_irshift_impl(module, a, b);
+
+exit:
+    return return_value;
+}
+
+PyDoc_STRVAR(_operator_iand__doc__,
+"iand($module, a, b, /)\n"
+"--\n"
+"\n"
+"Same as a &= b.");
+
+#define _OPERATOR_IAND_METHODDEF    \
+    {"iand", (PyCFunction)_operator_iand, METH_VARARGS, _operator_iand__doc__},
+
+static PyObject *
+_operator_iand_impl(PyModuleDef *module, PyObject *a, PyObject *b);
+
+static PyObject *
+_operator_iand(PyModuleDef *module, PyObject *args)
+{
+    PyObject *return_value = NULL;
+    PyObject *a;
+    PyObject *b;
+
+    if (!PyArg_UnpackTuple(args, "iand",
+        2, 2,
+        &a, &b))
+        goto exit;
+    return_value = _operator_iand_impl(module, a, b);
+
+exit:
+    return return_value;
+}
+
+PyDoc_STRVAR(_operator_ixor__doc__,
+"ixor($module, a, b, /)\n"
+"--\n"
+"\n"
+"Same as a ^= b.");
+
+#define _OPERATOR_IXOR_METHODDEF    \
+    {"ixor", (PyCFunction)_operator_ixor, METH_VARARGS, _operator_ixor__doc__},
+
+static PyObject *
+_operator_ixor_impl(PyModuleDef *module, PyObject *a, PyObject *b);
+
+static PyObject *
+_operator_ixor(PyModuleDef *module, PyObject *args)
+{
+    PyObject *return_value = NULL;
+    PyObject *a;
+    PyObject *b;
+
+    if (!PyArg_UnpackTuple(args, "ixor",
+        2, 2,
+        &a, &b))
+        goto exit;
+    return_value = _operator_ixor_impl(module, a, b);
+
+exit:
+    return return_value;
+}
+
+PyDoc_STRVAR(_operator_ior__doc__,
+"ior($module, a, b, /)\n"
+"--\n"
+"\n"
+"Same as a |= b.");
+
+#define _OPERATOR_IOR_METHODDEF    \
+    {"ior", (PyCFunction)_operator_ior, METH_VARARGS, _operator_ior__doc__},
+
+static PyObject *
+_operator_ior_impl(PyModuleDef *module, PyObject *a, PyObject *b);
+
+static PyObject *
+_operator_ior(PyModuleDef *module, PyObject *args)
+{
+    PyObject *return_value = NULL;
+    PyObject *a;
+    PyObject *b;
+
+    if (!PyArg_UnpackTuple(args, "ior",
+        2, 2,
+        &a, &b))
+        goto exit;
+    return_value = _operator_ior_impl(module, a, b);
+
+exit:
+    return return_value;
+}
+
+PyDoc_STRVAR(_operator_concat__doc__,
+"concat($module, a, b, /)\n"
+"--\n"
+"\n"
+"Same as a + b, for a and b sequences.");
+
+#define _OPERATOR_CONCAT_METHODDEF    \
+    {"concat", (PyCFunction)_operator_concat, METH_VARARGS, _operator_concat__doc__},
+
+static PyObject *
+_operator_concat_impl(PyModuleDef *module, PyObject *a, PyObject *b);
+
+static PyObject *
+_operator_concat(PyModuleDef *module, PyObject *args)
+{
+    PyObject *return_value = NULL;
+    PyObject *a;
+    PyObject *b;
+
+    if (!PyArg_UnpackTuple(args, "concat",
+        2, 2,
+        &a, &b))
+        goto exit;
+    return_value = _operator_concat_impl(module, a, b);
+
+exit:
+    return return_value;
+}
+
+PyDoc_STRVAR(_operator_iconcat__doc__,
+"iconcat($module, a, b, /)\n"
+"--\n"
+"\n"
+"Same as a += b, for a and b sequences.");
+
+#define _OPERATOR_ICONCAT_METHODDEF    \
+    {"iconcat", (PyCFunction)_operator_iconcat, METH_VARARGS, _operator_iconcat__doc__},
+
+static PyObject *
+_operator_iconcat_impl(PyModuleDef *module, PyObject *a, PyObject *b);
+
+static PyObject *
+_operator_iconcat(PyModuleDef *module, PyObject *args)
+{
+    PyObject *return_value = NULL;
+    PyObject *a;
+    PyObject *b;
+
+    if (!PyArg_UnpackTuple(args, "iconcat",
+        2, 2,
+        &a, &b))
+        goto exit;
+    return_value = _operator_iconcat_impl(module, a, b);
+
+exit:
+    return return_value;
+}
+
+PyDoc_STRVAR(_operator_contains__doc__,
+"contains($module, a, b, /)\n"
+"--\n"
+"\n"
+"Same as b in a (note reversed operands).");
+
+#define _OPERATOR_CONTAINS_METHODDEF    \
+    {"contains", (PyCFunction)_operator_contains, METH_VARARGS, _operator_contains__doc__},
+
+static int
+_operator_contains_impl(PyModuleDef *module, PyObject *a, PyObject *b);
+
+static PyObject *
+_operator_contains(PyModuleDef *module, PyObject *args)
+{
+    PyObject *return_value = NULL;
+    PyObject *a;
+    PyObject *b;
+    int _return_value;
+
+    if (!PyArg_UnpackTuple(args, "contains",
+        2, 2,
+        &a, &b))
+        goto exit;
+    _return_value = _operator_contains_impl(module, a, b);
+    if ((_return_value == -1) && PyErr_Occurred())
+        goto exit;
+    return_value = PyBool_FromLong((long)_return_value);
+
+exit:
+    return return_value;
+}
+
+PyDoc_STRVAR(_operator_indexOf__doc__,
+"indexOf($module, a, b, /)\n"
+"--\n"
+"\n"
+"Return the first index of b in a.");
+
+#define _OPERATOR_INDEXOF_METHODDEF    \
+    {"indexOf", (PyCFunction)_operator_indexOf, METH_VARARGS, _operator_indexOf__doc__},
+
+static Py_ssize_t
+_operator_indexOf_impl(PyModuleDef *module, PyObject *a, PyObject *b);
+
+static PyObject *
+_operator_indexOf(PyModuleDef *module, PyObject *args)
+{
+    PyObject *return_value = NULL;
+    PyObject *a;
+    PyObject *b;
+    Py_ssize_t _return_value;
+
+    if (!PyArg_UnpackTuple(args, "indexOf",
+        2, 2,
+        &a, &b))
+        goto exit;
+    _return_value = _operator_indexOf_impl(module, a, b);
+    if ((_return_value == -1) && PyErr_Occurred())
+        goto exit;
+    return_value = PyLong_FromSsize_t(_return_value);
+
+exit:
+    return return_value;
+}
+
+PyDoc_STRVAR(_operator_countOf__doc__,
+"countOf($module, a, b, /)\n"
+"--\n"
+"\n"
+"Return the number of times b occurs in a.");
+
+#define _OPERATOR_COUNTOF_METHODDEF    \
+    {"countOf", (PyCFunction)_operator_countOf, METH_VARARGS, _operator_countOf__doc__},
+
+static Py_ssize_t
+_operator_countOf_impl(PyModuleDef *module, PyObject *a, PyObject *b);
+
+static PyObject *
+_operator_countOf(PyModuleDef *module, PyObject *args)
+{
+    PyObject *return_value = NULL;
+    PyObject *a;
+    PyObject *b;
+    Py_ssize_t _return_value;
+
+    if (!PyArg_UnpackTuple(args, "countOf",
+        2, 2,
+        &a, &b))
+        goto exit;
+    _return_value = _operator_countOf_impl(module, a, b);
+    if ((_return_value == -1) && PyErr_Occurred())
+        goto exit;
+    return_value = PyLong_FromSsize_t(_return_value);
+
+exit:
+    return return_value;
+}
+
+PyDoc_STRVAR(_operator_getitem__doc__,
+"getitem($module, a, b, /)\n"
+"--\n"
+"\n"
+"Same as a[b].");
+
+#define _OPERATOR_GETITEM_METHODDEF    \
+    {"getitem", (PyCFunction)_operator_getitem, METH_VARARGS, _operator_getitem__doc__},
+
+static PyObject *
+_operator_getitem_impl(PyModuleDef *module, PyObject *a, PyObject *b);
+
+static PyObject *
+_operator_getitem(PyModuleDef *module, PyObject *args)
+{
+    PyObject *return_value = NULL;
+    PyObject *a;
+    PyObject *b;
+
+    if (!PyArg_UnpackTuple(args, "getitem",
+        2, 2,
+        &a, &b))
+        goto exit;
+    return_value = _operator_getitem_impl(module, a, b);
+
+exit:
+    return return_value;
+}
+
+PyDoc_STRVAR(_operator_setitem__doc__,
+"setitem($module, a, b, c, /)\n"
+"--\n"
+"\n"
+"Same as a[b] = c.");
+
+#define _OPERATOR_SETITEM_METHODDEF    \
+    {"setitem", (PyCFunction)_operator_setitem, METH_VARARGS, _operator_setitem__doc__},
+
+static PyObject *
+_operator_setitem_impl(PyModuleDef *module, PyObject *a, PyObject *b,
+                       PyObject *c);
+
+static PyObject *
+_operator_setitem(PyModuleDef *module, PyObject *args)
+{
+    PyObject *return_value = NULL;
+    PyObject *a;
+    PyObject *b;
+    PyObject *c;
+
+    if (!PyArg_UnpackTuple(args, "setitem",
+        3, 3,
+        &a, &b, &c))
+        goto exit;
+    return_value = _operator_setitem_impl(module, a, b, c);
+
+exit:
+    return return_value;
+}
+
+PyDoc_STRVAR(_operator_delitem__doc__,
+"delitem($module, a, b, /)\n"
+"--\n"
+"\n"
+"Same as del a[b].");
+
+#define _OPERATOR_DELITEM_METHODDEF    \
+    {"delitem", (PyCFunction)_operator_delitem, METH_VARARGS, _operator_delitem__doc__},
+
+static PyObject *
+_operator_delitem_impl(PyModuleDef *module, PyObject *a, PyObject *b);
+
+static PyObject *
+_operator_delitem(PyModuleDef *module, PyObject *args)
+{
+    PyObject *return_value = NULL;
+    PyObject *a;
+    PyObject *b;
+
+    if (!PyArg_UnpackTuple(args, "delitem",
+        2, 2,
+        &a, &b))
+        goto exit;
+    return_value = _operator_delitem_impl(module, a, b);
+
+exit:
+    return return_value;
+}
+
+PyDoc_STRVAR(_operator_lt__doc__,
+"lt($module, a, b, /)\n"
+"--\n"
+"\n"
+"Same as a < b.");
+
+#define _OPERATOR_LT_METHODDEF    \
+    {"lt", (PyCFunction)_operator_lt, METH_VARARGS, _operator_lt__doc__},
+
+static PyObject *
+_operator_lt_impl(PyModuleDef *module, PyObject *a, PyObject *b);
+
+static PyObject *
+_operator_lt(PyModuleDef *module, PyObject *args)
+{
+    PyObject *return_value = NULL;
+    PyObject *a;
+    PyObject *b;
+
+    if (!PyArg_UnpackTuple(args, "lt",
+        2, 2,
+        &a, &b))
+        goto exit;
+    return_value = _operator_lt_impl(module, a, b);
+
+exit:
+    return return_value;
+}
+
+PyDoc_STRVAR(_operator_le__doc__,
+"le($module, a, b, /)\n"
+"--\n"
+"\n"
+"Same as a <= b.");
+
+#define _OPERATOR_LE_METHODDEF    \
+    {"le", (PyCFunction)_operator_le, METH_VARARGS, _operator_le__doc__},
+
+static PyObject *
+_operator_le_impl(PyModuleDef *module, PyObject *a, PyObject *b);
+
+static PyObject *
+_operator_le(PyModuleDef *module, PyObject *args)
+{
+    PyObject *return_value = NULL;
+    PyObject *a;
+    PyObject *b;
+
+    if (!PyArg_UnpackTuple(args, "le",
+        2, 2,
+        &a, &b))
+        goto exit;
+    return_value = _operator_le_impl(module, a, b);
+
+exit:
+    return return_value;
+}
+
+PyDoc_STRVAR(_operator_eq__doc__,
+"eq($module, a, b, /)\n"
+"--\n"
+"\n"
+"Same as a == b.");
+
+#define _OPERATOR_EQ_METHODDEF    \
+    {"eq", (PyCFunction)_operator_eq, METH_VARARGS, _operator_eq__doc__},
+
+static PyObject *
+_operator_eq_impl(PyModuleDef *module, PyObject *a, PyObject *b);
+
+static PyObject *
+_operator_eq(PyModuleDef *module, PyObject *args)
+{
+    PyObject *return_value = NULL;
+    PyObject *a;
+    PyObject *b;
+
+    if (!PyArg_UnpackTuple(args, "eq",
+        2, 2,
+        &a, &b))
+        goto exit;
+    return_value = _operator_eq_impl(module, a, b);
+
+exit:
+    return return_value;
+}
+
+PyDoc_STRVAR(_operator_ne__doc__,
+"ne($module, a, b, /)\n"
+"--\n"
+"\n"
+"Same as a != b.");
+
+#define _OPERATOR_NE_METHODDEF    \
+    {"ne", (PyCFunction)_operator_ne, METH_VARARGS, _operator_ne__doc__},
+
+static PyObject *
+_operator_ne_impl(PyModuleDef *module, PyObject *a, PyObject *b);
+
+static PyObject *
+_operator_ne(PyModuleDef *module, PyObject *args)
+{
+    PyObject *return_value = NULL;
+    PyObject *a;
+    PyObject *b;
+
+    if (!PyArg_UnpackTuple(args, "ne",
+        2, 2,
+        &a, &b))
+        goto exit;
+    return_value = _operator_ne_impl(module, a, b);
+
+exit:
+    return return_value;
+}
+
+PyDoc_STRVAR(_operator_gt__doc__,
+"gt($module, a, b, /)\n"
+"--\n"
+"\n"
+"Same as a > b.");
+
+#define _OPERATOR_GT_METHODDEF    \
+    {"gt", (PyCFunction)_operator_gt, METH_VARARGS, _operator_gt__doc__},
+
+static PyObject *
+_operator_gt_impl(PyModuleDef *module, PyObject *a, PyObject *b);
+
+static PyObject *
+_operator_gt(PyModuleDef *module, PyObject *args)
+{
+    PyObject *return_value = NULL;
+    PyObject *a;
+    PyObject *b;
+
+    if (!PyArg_UnpackTuple(args, "gt",
+        2, 2,
+        &a, &b))
+        goto exit;
+    return_value = _operator_gt_impl(module, a, b);
+
+exit:
+    return return_value;
+}
+
+PyDoc_STRVAR(_operator_ge__doc__,
+"ge($module, a, b, /)\n"
+"--\n"
+"\n"
+"Same as a >= b.");
+
+#define _OPERATOR_GE_METHODDEF    \
+    {"ge", (PyCFunction)_operator_ge, METH_VARARGS, _operator_ge__doc__},
+
+static PyObject *
+_operator_ge_impl(PyModuleDef *module, PyObject *a, PyObject *b);
+
+static PyObject *
+_operator_ge(PyModuleDef *module, PyObject *args)
+{
+    PyObject *return_value = NULL;
+    PyObject *a;
+    PyObject *b;
+
+    if (!PyArg_UnpackTuple(args, "ge",
+        2, 2,
+        &a, &b))
+        goto exit;
+    return_value = _operator_ge_impl(module, a, b);
+
+exit:
+    return return_value;
+}
+
+PyDoc_STRVAR(_operator_pow__doc__,
+"pow($module, a, b, /)\n"
+"--\n"
+"\n"
+"Same as a ** b.");
+
+#define _OPERATOR_POW_METHODDEF    \
+    {"pow", (PyCFunction)_operator_pow, METH_VARARGS, _operator_pow__doc__},
+
+static PyObject *
+_operator_pow_impl(PyModuleDef *module, PyObject *a, PyObject *b);
+
+static PyObject *
+_operator_pow(PyModuleDef *module, PyObject *args)
+{
+    PyObject *return_value = NULL;
+    PyObject *a;
+    PyObject *b;
+
+    if (!PyArg_UnpackTuple(args, "pow",
+        2, 2,
+        &a, &b))
+        goto exit;
+    return_value = _operator_pow_impl(module, a, b);
+
+exit:
+    return return_value;
+}
+
+PyDoc_STRVAR(_operator_ipow__doc__,
+"ipow($module, a, b, /)\n"
+"--\n"
+"\n"
+"Same as a **= b.");
+
+#define _OPERATOR_IPOW_METHODDEF    \
+    {"ipow", (PyCFunction)_operator_ipow, METH_VARARGS, _operator_ipow__doc__},
+
+static PyObject *
+_operator_ipow_impl(PyModuleDef *module, PyObject *a, PyObject *b);
+
+static PyObject *
+_operator_ipow(PyModuleDef *module, PyObject *args)
+{
+    PyObject *return_value = NULL;
+    PyObject *a;
+    PyObject *b;
+
+    if (!PyArg_UnpackTuple(args, "ipow",
+        2, 2,
+        &a, &b))
+        goto exit;
+    return_value = _operator_ipow_impl(module, a, b);
+
+exit:
+    return return_value;
+}
+
+PyDoc_STRVAR(_operator_index__doc__,
+"index($module, a, /)\n"
+"--\n"
+"\n"
+"Same as a.__index__()");
+
+#define _OPERATOR_INDEX_METHODDEF    \
+    {"index", (PyCFunction)_operator_index, METH_O, _operator_index__doc__},
+
+PyDoc_STRVAR(_operator_is___doc__,
+"is_($module, a, b, /)\n"
+"--\n"
+"\n"
+"Same as a is b.");
+
+#define _OPERATOR_IS__METHODDEF    \
+    {"is_", (PyCFunction)_operator_is_, METH_VARARGS, _operator_is___doc__},
+
+static PyObject *
+_operator_is__impl(PyModuleDef *module, PyObject *a, PyObject *b);
+
+static PyObject *
+_operator_is_(PyModuleDef *module, PyObject *args)
+{
+    PyObject *return_value = NULL;
+    PyObject *a;
+    PyObject *b;
+
+    if (!PyArg_UnpackTuple(args, "is_",
+        2, 2,
+        &a, &b))
+        goto exit;
+    return_value = _operator_is__impl(module, a, b);
+
+exit:
+    return return_value;
+}
+
+PyDoc_STRVAR(_operator_is_not__doc__,
+"is_not($module, a, b, /)\n"
+"--\n"
+"\n"
+"Same as a is not b.");
+
+#define _OPERATOR_IS_NOT_METHODDEF    \
+    {"is_not", (PyCFunction)_operator_is_not, METH_VARARGS, _operator_is_not__doc__},
+
+static PyObject *
+_operator_is_not_impl(PyModuleDef *module, PyObject *a, PyObject *b);
+
+static PyObject *
+_operator_is_not(PyModuleDef *module, PyObject *args)
+{
+    PyObject *return_value = NULL;
+    PyObject *a;
+    PyObject *b;
+
+    if (!PyArg_UnpackTuple(args, "is_not",
+        2, 2,
+        &a, &b))
+        goto exit;
+    return_value = _operator_is_not_impl(module, a, b);
+
+exit:
+    return return_value;
+}
+
+PyDoc_STRVAR(_operator_length_hint__doc__,
+"length_hint($module, obj, default=0, /)\n"
+"--\n"
+"\n"
+"Return an estimate of the number of items in obj.\n"
+"\n"
+"This is useful for presizing containers when building from an iterable.\n"
+"\n"
+"If the object supports len(), the result will be exact.\n"
+"Otherwise, it may over- or under-estimate by an arbitrary amount.\n"
+"The result will be an integer >= 0.");
+
+#define _OPERATOR_LENGTH_HINT_METHODDEF    \
+    {"length_hint", (PyCFunction)_operator_length_hint, METH_VARARGS, _operator_length_hint__doc__},
+
+static PyObject *
+_operator_length_hint_impl(PyModuleDef *module, PyObject *obj,
+                           Py_ssize_t defaultvalue);
+
+static PyObject *
+_operator_length_hint(PyModuleDef *module, PyObject *args)
+{
+    PyObject *return_value = NULL;
+    PyObject *obj;
+    Py_ssize_t defaultvalue = 0;
+
+    if (!PyArg_ParseTuple(args, "O|n:length_hint",
+        &obj, &defaultvalue))
+        goto exit;
+    return_value = _operator_length_hint_impl(module, obj, defaultvalue);
+
+exit:
+    return return_value;
+}
+
+PyDoc_STRVAR(_operator__compare_digest__doc__,
+"_compare_digest($module, /, a, b)\n"
+"--\n"
+"\n"
+"Return \'a == b\'.\n"
+"\n"
+"This function uses an approach designed to prevent\n"
+"timing analysis, making it appropriate for cryptography.\n"
+"\n"
+"a and b must both be of the same type: either str (ASCII only),\n"
+"or any bytes-like object.\n"
+"\n"
+"Note: If a and b are of different lengths, or if an error occurs,\n"
+"a timing attack could theoretically reveal information about the\n"
+"types and lengths of a and b--but not their values.");
+
+#define _OPERATOR__COMPARE_DIGEST_METHODDEF    \
+    {"_compare_digest", (PyCFunction)_operator__compare_digest, METH_VARARGS|METH_KEYWORDS, _operator__compare_digest__doc__},
+
+static PyObject *
+_operator__compare_digest_impl(PyModuleDef *module, PyObject *a, PyObject *b);
+
+static PyObject *
+_operator__compare_digest(PyModuleDef *module, PyObject *args, PyObject *kwargs)
+{
+    PyObject *return_value = NULL;
+    static char *_keywords[] = {"a", "b", NULL};
+    PyObject *a;
+    PyObject *b;
+
+    if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:_compare_digest", _keywords,
+        &a, &b))
+        goto exit;
+    return_value = _operator__compare_digest_impl(module, a, b);
+
+exit:
+    return return_value;
+}
+/*[clinic end generated code: output=44cc6c61a40ee14e input=a9049054013a1b77]*/