#include "Python.h"

#include <ctype.h>

#include "structmember.h" /* we need the offsetof() macro from there */

#include "longintrepr.h"

static PyObject *

type_error(const char *msg, PyObject *obj)

{

PyErr_Format(PyExc_TypeError, msg, obj->ob_type->tp_name);

return NULL;

}

static PyObject *

null_error(void)

{

if (!PyErr_Occurred())

PyErr_SetString(PyExc_SystemError,

"null argument to internal routine");

return NULL;

}

PyObject *

PyObject_Type(PyObject *o)

{

PyObject *v;

if (o == NULL)

return null_error();

v = (PyObject *)o->ob_type;

Py_INCREF(v);

return v;

}

PyObject_Size(PyObject *o)

{

PySequenceMethods *m;

if (o == NULL) {

null_error();

return -1;

}

m = o->ob_type->tp_as_sequence;

if (m && m->sq_length)

return m->sq_length(o);

return PyMapping_Size(o);

}

#undef PyObject_Length

PyObject_Length(PyObject *o)

{

return PyObject_Size(o);

}

#define PyObject_Length PyObject_Size

_PyObject_HasLen(PyObject *o) {

return (Py_TYPE(o)->tp_as_sequence && Py_TYPE(o)->tp_as_sequence->sq_length) ||

(Py_TYPE(o)->tp_as_mapping && Py_TYPE(o)->tp_as_mapping->mp_length);

}

PyObject_LengthHint(PyObject *o, Py_ssize_t defaultvalue)

{

PyObject *hint, *result;

Py_ssize_t res;

_Py_IDENTIFIER(__length_hint__);

if (_PyObject_HasLen(o)) {

res = PyObject_Length(o);

if (res < 0 && PyErr_Occurred()) {

if (!PyErr_ExceptionMatches(PyExc_TypeError)) {

return -1;

}

PyErr_Clear();

}

else {

return res;

}

}

hint = _PyObject_LookupSpecial(o, &PyId___length_hint__);

if (hint == NULL) {

if (PyErr_Occurred()) {

return -1;

}

return defaultvalue;

}

result = PyObject_CallFunctionObjArgs(hint, NULL);

Py_DECREF(hint);

if (result == NULL) {

if (PyErr_ExceptionMatches(PyExc_TypeError)) {

PyErr_Clear();

return defaultvalue;

}

return -1;

}

else if (result == Py_NotImplemented) {

Py_DECREF(result);

return defaultvalue;

}

if (!PyLong_Check(result)) {

PyErr_Format(PyExc_TypeError, "__length_hint__ must be an integer, not %.100s",

Py_TYPE(result)->tp_name);

Py_DECREF(result);

return -1;

}

res = PyLong_AsSsize_t(result);

Py_DECREF(result);

if (res < 0 && PyErr_Occurred()) {

return -1;

}

if (res < 0) {

PyErr_Format(PyExc_ValueError, "__length_hint__() should return >= 0");

return -1;

}

return res;

}

PyObject *

PyObject_GetItem(PyObject *o, PyObject *key)

{

PyMappingMethods *m;

if (o == NULL || key == NULL)

return null_error();

m = o->ob_type->tp_as_mapping;

if (m && m->mp_subscript)

return m->mp_subscript(o, key);

if (o->ob_type->tp_as_sequence) {

if (PyIndex_Check(key)) {

Py_ssize_t key_value;

key_value = PyNumber_AsSsize_t(key, PyExc_IndexError);

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

return NULL;

return PySequence_GetItem(o, key_value);

}

else if (o->ob_type->tp_as_sequence->sq_item)

return type_error("sequence index must "

"be integer, not '%.200s'", key);

}

return type_error("'%.200s' object is not subscriptable", o);

}

PyObject_SetItem(PyObject *o, PyObject *key, PyObject *value)

{

PyMappingMethods *m;

if (o == NULL || key == NULL || value == NULL) {

null_error();

return -1;

}

m = o->ob_type->tp_as_mapping;

if (m && m->mp_ass_subscript)

return m->mp_ass_subscript(o, key, value);

if (o->ob_type->tp_as_sequence) {

if (PyIndex_Check(key)) {

Py_ssize_t key_value;

key_value = PyNumber_AsSsize_t(key, PyExc_IndexError);

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

return -1;

return PySequence_SetItem(o, key_value, value);

}

else if (o->ob_type->tp_as_sequence->sq_ass_item) {

type_error("sequence index must be "

"integer, not '%.200s'", key);

return -1;

}

}

type_error("'%.200s' object does not support item assignment", o);

return -1;

}

PyObject_DelItem(PyObject *o, PyObject *key)

{

PyMappingMethods *m;

if (o == NULL || key == NULL) {

null_error();

return -1;

}

m = o->ob_type->tp_as_mapping;

if (m && m->mp_ass_subscript)

return m->mp_ass_subscript(o, key, (PyObject*)NULL);

if (o->ob_type->tp_as_sequence) {

if (PyIndex_Check(key)) {

Py_ssize_t key_value;

key_value = PyNumber_AsSsize_t(key, PyExc_IndexError);

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

return -1;

return PySequence_DelItem(o, key_value);

}

else if (o->ob_type->tp_as_sequence->sq_ass_item) {

type_error("sequence index must be "

"integer, not '%.200s'", key);

return -1;

}

}

type_error("'%.200s' object does not support item deletion", o);

return -1;

}

PyObject_DelItemString(PyObject *o, const char *key)

{

PyObject *okey;

int ret;

if (o == NULL || key == NULL) {

null_error();

return -1;

}

okey = PyUnicode_FromString(key);

if (okey == NULL)

return -1;

ret = PyObject_DelItem(o, okey);

Py_DECREF(okey);

return ret;

}

PyObject_AsCharBuffer(PyObject *obj,

const char **buffer,

Py_ssize_t *buffer_len)

{

return PyObject_AsReadBuffer(obj, (const void **)buffer, buffer_len);

}

PyObject_CheckReadBuffer(PyObject *obj)

{

PyBufferProcs *pb = obj->ob_type->tp_as_buffer;

Py_buffer view;

if (pb == NULL ||

pb->bf_getbuffer == NULL)

return 0;

if ((*pb->bf_getbuffer)(obj, &view, PyBUF_SIMPLE) == -1) {

PyErr_Clear();

return 0;

}

PyBuffer_Release(&view);

return 1;

}

int PyObject_AsReadBuffer(PyObject *obj,

const void **buffer,

Py_ssize_t *buffer_len)

{

Py_buffer view;

if (obj == NULL || buffer == NULL || buffer_len == NULL) {

null_error();

return -1;

}

if (PyObject_GetBuffer(obj, &view, PyBUF_SIMPLE) != 0)

return -1;

*buffer = view.buf;

*buffer_len = view.len;

PyBuffer_Release(&view);

return 0;

}

int PyObject_AsWriteBuffer(PyObject *obj,

void **buffer,

Py_ssize_t *buffer_len)

{

PyBufferProcs *pb;

Py_buffer view;

if (obj == NULL || buffer == NULL || buffer_len == NULL) {

null_error();

return -1;

}

pb = obj->ob_type->tp_as_buffer;

if (pb == NULL ||

pb->bf_getbuffer == NULL ||

((*pb->bf_getbuffer)(obj, &view, PyBUF_WRITABLE) != 0)) {

PyErr_SetString(PyExc_TypeError,

"expected a writable bytes-like object");

return -1;

}

*buffer = view.buf;

*buffer_len = view.len;

PyBuffer_Release(&view);

return 0;

}

PyObject_GetBuffer(PyObject *obj, Py_buffer *view, int flags)

{

PyBufferProcs *pb = obj->ob_type->tp_as_buffer;

if (pb == NULL || pb->bf_getbuffer == NULL) {

PyErr_Format(PyExc_TypeError,

"a bytes-like object is required, not '%.100s'",

Py_TYPE(obj)->tp_name);

return -1;

}

return (*pb->bf_getbuffer)(obj, view, flags);

}

static int

_IsFortranContiguous(const Py_buffer *view)

{

Py_ssize_t sd, dim;

int i;

/* 1) len = product(shape) * itemsize

if (view->len == 0) return 1;

if (view->strides == NULL) { /* C-contiguous by definition */

/* Trivially F-contiguous */

if (view->ndim <= 1) return 1;

/* ndim > 1 implies shape != NULL */

assert(view->shape != NULL);

/* Effectively 1-d */

sd = 0;

for (i=0; i<view->ndim; i++) {

if (view->shape[i] > 1) sd += 1;

}

return sd <= 1;

}

/* strides != NULL implies both of these */

assert(view->ndim > 0);

assert(view->shape != NULL);

sd = view->itemsize;

for (i=0; i<view->ndim; i++) {

dim = view->shape[i];

if (dim > 1 && view->strides[i] != sd) {

return 0;

}

sd *= dim;

}

return 1;

}

static int

_IsCContiguous(const Py_buffer *view)

{

Py_ssize_t sd, dim;

int i;

/* 1) len = product(shape) * itemsize

if (view->len == 0) return 1;

if (view->strides == NULL) return 1; /* C-contiguous by definition */

/* strides != NULL implies both of these */

assert(view->ndim > 0);

assert(view->shape != NULL);

sd = view->itemsize;

for (i=view->ndim-1; i>=0; i--) {

dim = view->shape[i];

if (dim > 1 && view->strides[i] != sd) {

return 0;

}

sd *= dim;

}

return 1;

}

PyBuffer_IsContiguous(const Py_buffer *view, char order)

{

if (view->suboffsets != NULL) return 0;

if (order == 'C')

return _IsCContiguous(view);

else if (order == 'F')

return _IsFortranContiguous(view);

else if (order == 'A')

return (_IsCContiguous(view) || _IsFortranContiguous(view));

return 0;

}

PyBuffer_GetPointer(Py_buffer *view, Py_ssize_t *indices)

{

char* pointer;

int i;

pointer = (char *)view->buf;

for (i = 0; i < view->ndim; i++) {

pointer += view->strides[i]*indices[i];

if ((view->suboffsets != NULL) && (view->suboffsets[i] >= 0)) {

pointer = *((char**)pointer) + view->suboffsets[i];

}

}

return (void*)pointer;

}

_Py_add_one_to_index_F(int nd, Py_ssize_t *index, const Py_ssize_t *shape)

{

int k;

for (k=0; k<nd; k++) {

if (index[k] < shape[k]-1) {

index[k]++;

break;

}

else {

index[k] = 0;

}

}

}

_Py_add_one_to_index_C(int nd, Py_ssize_t *index, const Py_ssize_t *shape)

{

int k;

for (k=nd-1; k>=0; k--) {

if (index[k] < shape[k]-1) {

index[k]++;

break;

}

else {

index[k] = 0;

}

}

}

PyBuffer_FromContiguous(Py_buffer *view, void *buf, Py_ssize_t len, char fort)

{

int k;

void (*addone)(int, Py_ssize_t *, const Py_ssize_t *);

Py_ssize_t *indices, elements;

char *src, *ptr;

if (len > view->len) {

len = view->len;

}

if (PyBuffer_IsContiguous(view, fort)) {

/* simplest copy is all that is needed */

memcpy(view->buf, buf, len);

return 0;

}

/* Otherwise a more elaborate scheme is needed */

/* view->ndim <= 64 */

indices = (Py_ssize_t *)PyMem_Malloc(sizeof(Py_ssize_t)*(view->ndim));

if (indices == NULL) {

PyErr_NoMemory();

return -1;

}

for (k=0; k<view->ndim;k++) {

indices[k] = 0;

}

if (fort == 'F') {

addone = _Py_add_one_to_index_F;

}

else {

addone = _Py_add_one_to_index_C;

}

src = buf;

/* XXX : This is not going to be the fastest code in the world

elements = len / view->itemsize;

while (elements--) {

ptr = PyBuffer_GetPointer(view, indices);

memcpy(ptr, src, view->itemsize);

src += view->itemsize;

addone(view->ndim, indices, view->shape);

}

PyMem_Free(indices);

return 0;

}

int PyObject_CopyData(PyObject *dest, PyObject *src)

{

Py_buffer view_dest, view_src;

int k;

Py_ssize_t *indices, elements;

char *dptr, *sptr;

if (!PyObject_CheckBuffer(dest) ||

!PyObject_CheckBuffer(src)) {

PyErr_SetString(PyExc_TypeError,

"both destination and source must be "\

"bytes-like objects");

return -1;

}

if (PyObject_GetBuffer(dest, &view_dest, PyBUF_FULL) != 0) return -1;

if (PyObject_GetBuffer(src, &view_src, PyBUF_FULL_RO) != 0) {

PyBuffer_Release(&view_dest);

return -1;

}

if (view_dest.len < view_src.len) {

PyErr_SetString(PyExc_BufferError,

"destination is too small to receive data from source");

PyBuffer_Release(&view_dest);

PyBuffer_Release(&view_src);

return -1;

}

if ((PyBuffer_IsContiguous(&view_dest, 'C') &&

PyBuffer_IsContiguous(&view_src, 'C')) ||

(PyBuffer_IsContiguous(&view_dest, 'F') &&

PyBuffer_IsContiguous(&view_src, 'F'))) {

/* simplest copy is all that is needed */

memcpy(view_dest.buf, view_src.buf, view_src.len);

PyBuffer_Release(&view_dest);

PyBuffer_Release(&view_src);

return 0;

}

/* Otherwise a more elaborate copy scheme is needed */

/* XXX(nnorwitz): need to check for overflow! */

indices = (Py_ssize_t *)PyMem_Malloc(sizeof(Py_ssize_t)*view_src.ndim);

if (indices == NULL) {

PyErr_NoMemory();

PyBuffer_Release(&view_dest);

PyBuffer_Release(&view_src);

return -1;

}

for (k=0; k<view_src.ndim;k++) {

indices[k] = 0;

}

elements = 1;

for (k=0; k<view_src.ndim; k++) {

/* XXX(nnorwitz): can this overflow? */

elements *= view_src.shape[k];

}

while (elements--) {

_Py_add_one_to_index_C(view_src.ndim, indices, view_src.shape);

dptr = PyBuffer_GetPointer(&view_dest, indices);

sptr = PyBuffer_GetPointer(&view_src, indices);

memcpy(dptr, sptr, view_src.itemsize);

}

PyMem_Free(indices);

PyBuffer_Release(&view_dest);

PyBuffer_Release(&view_src);

return 0;

}

PyBuffer_FillContiguousStrides(int nd, Py_ssize_t *shape,

Py_ssize_t *strides, int itemsize,

char fort)

{

int k;

Py_ssize_t sd;

sd = itemsize;

if (fort == 'F') {

for (k=0; k<nd; k++) {

strides[k] = sd;

sd *= shape[k];

}

}

else {

for (k=nd-1; k>=0; k--) {

strides[k] = sd;

sd *= shape[k];

}

}

return;

}

PyBuffer_FillInfo(Py_buffer *view, PyObject *obj, void *buf, Py_ssize_t len,

int readonly, int flags)

{

if (view == NULL) {

PyErr_SetString(PyExc_BufferError,

"PyBuffer_FillInfo: view==NULL argument is obsolete");

return -1;

}

if (((flags & PyBUF_WRITABLE) == PyBUF_WRITABLE) &&

(readonly == 1)) {

PyErr_SetString(PyExc_BufferError,

"Object is not writable.");

return -1;

}

view->obj = obj;

if (obj)

Py_INCREF(obj);

view->buf = buf;

view->len = len;

view->readonly = readonly;

view->itemsize = 1;

view->format = NULL;

if ((flags & PyBUF_FORMAT) == PyBUF_FORMAT)

view->format = "B";

view->ndim = 1;

view->shape = NULL;

if ((flags & PyBUF_ND) == PyBUF_ND)

view->shape = &(view->len);

view->strides = NULL;

if ((flags & PyBUF_STRIDES) == PyBUF_STRIDES)

view->strides = &(view->itemsize);

view->suboffsets = NULL;

view->internal = NULL;

return 0;

}

PyBuffer_Release(Py_buffer *view)

{

PyObject *obj = view->obj;

PyBufferProcs *pb;

if (obj == NULL)

return;

pb = Py_TYPE(obj)->tp_as_buffer;

if (pb && pb->bf_releasebuffer)

pb->bf_releasebuffer(obj, view);

view->obj = NULL;

Py_DECREF(obj);

}

PyObject *

PyObject_Format(PyObject *obj, PyObject *format_spec)

{

PyObject *meth;

PyObject *empty = NULL;

PyObject *result = NULL;

_Py_IDENTIFIER(__format__);

/* If no format_spec is provided, use an empty string */

if (format_spec == NULL) {

empty = PyUnicode_New(0, 0);

format_spec = empty;

}

/* Find the (unbound!) __format__ method (a borrowed reference) */

meth = _PyObject_LookupSpecial(obj, &PyId___format__);

if (meth == NULL) {

if (!PyErr_Occurred())

PyErr_Format(PyExc_TypeError,

"Type %.100s doesn't define __format__",

Py_TYPE(obj)->tp_name);

goto done;

}

/* And call it. */

result = PyObject_CallFunctionObjArgs(meth, format_spec, NULL);

Py_DECREF(meth);

if (result && !PyUnicode_Check(result)) {

PyErr_Format(PyExc_TypeError,

"__format__ must return a str, not %.200s",

Py_TYPE(result)->tp_name);

Py_DECREF(result);

result = NULL;

goto done;

}

done:

Py_XDECREF(empty);

return result;

}

PyNumber_Check(PyObject *o)

{

return o && o->ob_type->tp_as_number &&

(o->ob_type->tp_as_number->nb_int ||

o->ob_type->tp_as_number->nb_float);

}

#define NB_SLOT(x) offsetof(PyNumberMethods, x)

#define NB_BINOP(nb_methods, slot) \

(*(binaryfunc*)(& ((char*)nb_methods)[slot]))

#define NB_TERNOP(nb_methods, slot) \

(*(ternaryfunc*)(& ((char*)nb_methods)[slot]))

static PyObject *

binary_op1(PyObject *v, PyObject *w, const int op_slot)

{

PyObject *x;

binaryfunc slotv = NULL;

binaryfunc slotw = NULL;

if (v->ob_type->tp_as_number != NULL)

slotv = NB_BINOP(v->ob_type->tp_as_number, op_slot);

if (w->ob_type != v->ob_type &&

w->ob_type->tp_as_number != NULL) {

slotw = NB_BINOP(w->ob_type->tp_as_number, op_slot);

if (slotw == slotv)

slotw = NULL;

}

if (slotv) {

if (slotw && PyType_IsSubtype(w->ob_type, v->ob_type)) {

x = slotw(v, w);

if (x != Py_NotImplemented)

return x;

Py_DECREF(x); /* can't do it */

slotw = NULL;

}

x = slotv(v, w);

if (x != Py_NotImplemented)

return x;

Py_DECREF(x); /* can't do it */

}

if (slotw) {

x = slotw(v, w);

if (x != Py_NotImplemented)

return x;

Py_DECREF(x); /* can't do it */

}

Py_RETURN_NOTIMPLEMENTED;

}

static PyObject *

binop_type_error(PyObject *v, PyObject *w, const char *op_name)

{

PyErr_Format(PyExc_TypeError,

"unsupported operand type(s) for %.100s: "

"'%.100s' and '%.100s'",

op_name,

v->ob_type->tp_name,

w->ob_type->tp_name);

return NULL;

}

static PyObject *

binary_op(PyObject *v, PyObject *w, const int op_slot, const char *op_name)

{

PyObject *result = binary_op1(v, w, op_slot);

if (result == Py_NotImplemented) {

Py_DECREF(result);

return binop_type_error(v, w, op_name);

}

return result;

}

static PyObject *

ternary_op(PyObject *v,

const char *op_name)

{

PyNumberMethods *mv, *mw, *mz;

PyObject *x = NULL;

ternaryfunc slotv = NULL;

ternaryfunc slotw = NULL;

ternaryfunc slotz = NULL;

mv = v->ob_type->tp_as_number;

mw = w->ob_type->tp_as_number;

if (mv != NULL)

slotv = NB_TERNOP(mv, op_slot);

if (w->ob_type != v->ob_type &&

mw != NULL) {

slotw = NB_TERNOP(mw, op_slot);

if (slotw == slotv)

slotw = NULL;

}

if (slotv) {

if (slotw && PyType_IsSubtype(w->ob_type, v->ob_type)) {

x = slotw(v, w, z);

if (x != Py_NotImplemented)

return x;

Py_DECREF(x); /* can't do it */

slotw = NULL;

}

x = slotv(v, w, z);

if (x != Py_NotImplemented)

return x;

Py_DECREF(x); /* can't do it */

}

if (slotw) {

x = slotw(v, w, z);

if (x != Py_NotImplemented)

return x;

Py_DECREF(x); /* can't do it */

}

mz = z->ob_type->tp_as_number;

if (mz != NULL) {

slotz = NB_TERNOP(mz, op_slot);

if (slotz == slotv || slotz == slotw)

slotz = NULL;

if (slotz) {

x = slotz(v, w, z);

if (x != Py_NotImplemented)

return x;

Py_DECREF(x); /* can't do it */

}

}

if (z == Py_None)

PyErr_Format(

PyExc_TypeError,

"unsupported operand type(s) for ** or pow(): "

"'%.100s' and '%.100s'",

v->ob_type->tp_name,

w->ob_type->tp_name);

else

PyErr_Format(

PyExc_TypeError,

"unsupported operand type(s) for pow(): "

"'%.100s', '%.100s', '%.100s'",

v->ob_type->tp_name,

w->ob_type->tp_name,

z->ob_type->tp_name);

return NULL;

}

#define BINARY_FUNC(func, op, op_name) \

PyObject * \

func(PyObject *v, PyObject *w) { \

return binary_op(v, w, NB_SLOT(op), op_name); \

}

BINARY_FUNC(PyNumber_Or, nb_or, "|")

BINARY_FUNC(PyNumber_Xor, nb_xor, "^")

BINARY_FUNC(PyNumber_And, nb_and, "&")

BINARY_FUNC(PyNumber_Lshift, nb_lshift, "<<")

BINARY_FUNC(PyNumber_Rshift, nb_rshift, ">>")

BINARY_FUNC(PyNumber_Subtract, nb_subtract, "-")

BINARY_FUNC(PyNumber_Divmod, nb_divmod, "divmod()")

PyObject *

PyNumber_Add(PyObject *v, PyObject *w)

{

PyObject *result = binary_op1(v, w, NB_SLOT(nb_add));

if (result == Py_NotImplemented) {

PySequenceMethods *m = v->ob_type->tp_as_sequence;

Py_DECREF(result);

if (m && m->sq_concat) {

return (*m->sq_concat)(v, w);

}

result = binop_type_error(v, w, "+");

}

return result;

}

static PyObject *

sequence_repeat(ssizeargfunc repeatfunc, PyObject *seq, PyObject *n)

{

Py_ssize_t count;

if (PyIndex_Check(n)) {

count = PyNumber_AsSsize_t(n, PyExc_OverflowError);

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

return NULL;

}

else {

return type_error("can't multiply sequence by "

"non-int of type '%.200s'", n);

}

return (*repeatfunc)(seq, count);

}

PyObject *

PyNumber_Multiply(PyObject *v, PyObject *w)

{

PyObject *result = binary_op1(v, w, NB_SLOT(nb_multiply));

if (result == Py_NotImplemented) {

PySequenceMethods *mv = v->ob_type->tp_as_sequence;

PySequenceMethods *mw = w->ob_type->tp_as_sequence;

Py_DECREF(result);

if (mv && mv->sq_repeat) {

return sequence_repeat(mv->sq_repeat, v, w);

}

else if (mw && mw->sq_repeat) {

return sequence_repeat(mw->sq_repeat, w, v);

}

result = binop_type_error(v, w, "*");

}

return result;

}

PyObject *

PyNumber_MatrixMultiply(PyObject *v, PyObject *w)

{

return binary_op(v, w, NB_SLOT(nb_matrix_multiply), "@");

}

PyObject *

PyNumber_FloorDivide(PyObject *v, PyObject *w)

{

return binary_op(v, w, NB_SLOT(nb_floor_divide), "//");

}

PyObject *

PyNumber_TrueDivide(PyObject *v, PyObject *w)

{

return binary_op(v, w, NB_SLOT(nb_true_divide), "/");

}

PyObject *

PyNumber_Remainder(PyObject *v, PyObject *w)

{

return binary_op(v, w, NB_SLOT(nb_remainder), "%");

}

PyObject *

PyNumber_Power(PyObject *v, PyObject *w, PyObject *z)

{

return ternary_op(v, w, z, NB_SLOT(nb_power), "** or pow()");

}

static PyObject *

binary_iop1(PyObject *v, PyObject *w, const int iop_slot, const int op_slot)

{

PyNumberMethods *mv = v->ob_type->tp_as_number;

if (mv != NULL) {

binaryfunc slot = NB_BINOP(mv, iop_slot);

if (slot) {

PyObject *x = (slot)(v, w);

if (x != Py_NotImplemented) {

return x;

}

Py_DECREF(x);

}

}

return binary_op1(v, w, op_slot);

}