Index: setup.py
===================================================================
--- setup.py	(revision 78631)
+++ setup.py	(working copy)
@@ -1759,7 +1759,8 @@
                    '_ctypes/callproc.c',
                    '_ctypes/stgdict.c',
                    '_ctypes/cfield.c',
-                   '_ctypes/malloc_closure.c']
+                   '_ctypes/malloc_closure.c',
+                   '_ctypes/cnumber.c']
         depends = ['_ctypes/ctypes.h']
 
         if sys.platform == 'darwin':
Index: Lib/ctypes/test/test_numbers.py
===================================================================
--- Lib/ctypes/test/test_numbers.py	(revision 78631)
+++ Lib/ctypes/test/test_numbers.py	(working copy)
@@ -219,6 +219,61 @@
 ##    def test_perf(self):
 ##        check_perf()
 
+class NumberOpsTestCase(unittest.TestCase):
+    ctype = c_double
+    def test_arithmetics(self):
+        a = self.ctype(2)
+        b = self.ctype(1)
+        self.assertEqual((a + b).value, 3)
+        self.assertEqual((a - b).value, 1)
+        self.assertEqual((a / b).value, 2)
+        self.assertEqual((a % b).value, 0)
+        self.assertEqual((+a).value, 2)
+
+    def test_negative(self):
+        a = self.ctype(2)
+        self.assertEqual((-a).value, -2)
+
+class UnsignedTest:
+    def test_negative(self):
+        a = self.ctype(1)
+        self.assertEqual((-a).value, 2**(8*sizeof(self.ctype)) - 1)
+
+
+class ByteOpsTestCase(NumberOpsTestCase):
+    ctype = c_byte
+
+class UByteOpsTestCase(UnsignedTest, NumberOpsTestCase):
+    ctype = c_ubyte
+
+class ShortOpsTestCase(NumberOpsTestCase):
+    ctype = c_short
+
+class UShortOpsTestCase(UnsignedTest, NumberOpsTestCase):
+    ctype = c_ushort
+
+class IntOpsTestCase(NumberOpsTestCase):
+    ctype = c_int
+
+class UIntOpsTestCase(UnsignedTest, NumberOpsTestCase):
+    ctype = c_uint
+
+class LongOpsTestCase(NumberOpsTestCase):
+    ctype = c_long
+
+class ULongOpsTestCase(UnsignedTest, NumberOpsTestCase):
+    ctype = c_ulong
+
+class FloatOpsTestCase(NumberOpsTestCase):
+    ctype = c_float
+
+class LongdoubleOpsTestCase(NumberOpsTestCase):
+    ctype = c_longdouble
+
+class ByteOpsTestCase(NumberOpsTestCase):
+    ctype = c_byte
+
+
 from ctypes import _SimpleCData
 class c_int_S(_SimpleCData):
     _type_ = "i"
Index: Modules/_ctypes/_ctypes.c
===================================================================
--- Modules/_ctypes/_ctypes.c	(revision 78631)
+++ Modules/_ctypes/_ctypes.c	(working copy)
@@ -2029,6 +2029,8 @@
 			return NULL;
 		}
 	};
+	/* Machine arithmetics support */
+	result->tp_as_number = _PyCData_NumberMethods(proto_str);
 
 	return (PyObject *)result;
 }
Index: Modules/_ctypes/ctypes.h
===================================================================
--- Modules/_ctypes/ctypes.h	(revision 78631)
+++ Modules/_ctypes/ctypes.h	(working copy)
@@ -63,15 +63,22 @@
 */
 union value {
 		char c[16];
+                signed char b;
+                unsigned char B;
+                short h;
+                unsigned short H;
 		short s;
 		int i;
+                unsigned int I;
 		long l;
+                unsigned long L;
 		float f;
 		double d;
 #ifdef HAVE_LONG_LONG
 		PY_LONG_LONG ll;
 #endif
 		long double D;
+		long double g;
 };
 
 /*
@@ -441,6 +448,9 @@
 extern PyObject *_ctypes_ptrtype_cache;
 PyObject *_ctypes_get_errobj(int **pspace);
 
+extern PyNumberMethods*
+_PyCData_NumberMethods(const char *proto);
+
 #ifdef MS_WIN32
 extern PyObject *ComError;
 #endif
Index: Modules/_ctypes/cnumber.c
===================================================================
--- Modules/_ctypes/cnumber.c	(revision 0)
+++ Modules/_ctypes/cnumber.c	(revision 0)
@@ -0,0 +1,976 @@
+/* Machine arithmetics support */
+#include "Python.h"
+
+#include <ffi.h>
+#ifdef MS_WIN32
+#include <windows.h>
+#endif
+#include "ctypes.h"
+#include <math.h>
+
+static PyObject *
+b_add(CDataObject *x, CDataObject *y)
+{
+    CDataObject *result;
+    result = (CDataObject *)Py_TYPE(x)->tp_new(x->ob_type, NULL, NULL);
+    if (result != NULL)
+	result->b_value.b = x->b_value.b + y->b_value.b;
+    return (PyObject *)result;
+}
+
+static PyObject *
+b_subtract(CDataObject *x, CDataObject *y)
+{
+    CDataObject *result;
+    result = (CDataObject *)Py_TYPE(x)->tp_new(x->ob_type, NULL, NULL);
+    if (result != NULL)
+	result->b_value.b = x->b_value.b - y->b_value.b;
+    return (PyObject *)result;
+}
+
+static PyObject *
+b_multiply(CDataObject *x, CDataObject *y)
+{
+    CDataObject *result;
+    result = (CDataObject *)Py_TYPE(x)->tp_new(x->ob_type, NULL, NULL);
+    if (result != NULL)
+	result->b_value.b = x->b_value.b * y->b_value.b;
+    return (PyObject *)result;
+}
+
+static PyObject *
+b_divide(CDataObject *x, CDataObject *y)
+{
+    CDataObject *result;
+    result = (CDataObject *)Py_TYPE(x)->tp_new(x->ob_type, NULL, NULL);
+    if (result != NULL)
+	    result->b_value.b = x->b_value.b / y->b_value.b;
+    return (PyObject *)result;
+}
+
+static PyObject *
+b_remainder(CDataObject *x, CDataObject *y)
+{
+    CDataObject *result;
+    result = (CDataObject *)Py_TYPE(x)->tp_new(x->ob_type, NULL, NULL);
+    if (result != NULL)
+	result->b_value.b = x->b_value.b % y->b_value.b;
+    return (PyObject *)result;
+}
+
+static PyObject *
+b_negative(CDataObject *x)
+{
+    CDataObject *result;
+    result = (CDataObject *)Py_TYPE(x)->tp_new(x->ob_type, NULL, NULL);
+    if (result != NULL)
+	result->b_value.b = -x->b_value.b;
+    return (PyObject *)result;
+}
+
+static PyObject *
+b_positive(CDataObject *x)
+{
+    CDataObject *result;
+    result = (CDataObject *)Py_TYPE(x)->tp_new(x->ob_type, NULL, NULL);
+    if (result != NULL)
+	result->b_value.b = +x->b_value.b;
+    return (PyObject *)result;
+}
+
+
+static PyObject *
+B_add(CDataObject *x, CDataObject *y)
+{
+    CDataObject *result;
+    result = (CDataObject *)Py_TYPE(x)->tp_new(x->ob_type, NULL, NULL);
+    if (result != NULL)
+	result->b_value.B = x->b_value.B + y->b_value.B;
+    return (PyObject *)result;
+}
+
+static PyObject *
+B_subtract(CDataObject *x, CDataObject *y)
+{
+    CDataObject *result;
+    result = (CDataObject *)Py_TYPE(x)->tp_new(x->ob_type, NULL, NULL);
+    if (result != NULL)
+	result->b_value.B = x->b_value.B - y->b_value.B;
+    return (PyObject *)result;
+}
+
+static PyObject *
+B_multiply(CDataObject *x, CDataObject *y)
+{
+    CDataObject *result;
+    result = (CDataObject *)Py_TYPE(x)->tp_new(x->ob_type, NULL, NULL);
+    if (result != NULL)
+	result->b_value.B = x->b_value.B * y->b_value.B;
+    return (PyObject *)result;
+}
+
+static PyObject *
+B_divide(CDataObject *x, CDataObject *y)
+{
+    CDataObject *result;
+    result = (CDataObject *)Py_TYPE(x)->tp_new(x->ob_type, NULL, NULL);
+    if (result != NULL)
+	    result->b_value.B = x->b_value.B / y->b_value.B;
+    return (PyObject *)result;
+}
+
+static PyObject *
+B_remainder(CDataObject *x, CDataObject *y)
+{
+    CDataObject *result;
+    result = (CDataObject *)Py_TYPE(x)->tp_new(x->ob_type, NULL, NULL);
+    if (result != NULL)
+	result->b_value.B = x->b_value.B %  y->b_value.B;
+    return (PyObject *)result;
+}
+
+static PyObject *
+B_negative(CDataObject *x)
+{
+    CDataObject *result;
+    result = (CDataObject *)Py_TYPE(x)->tp_new(x->ob_type, NULL, NULL);
+    if (result != NULL)
+	result->b_value.B = -x->b_value.B;
+    return (PyObject *)result;
+}
+
+static PyObject *
+B_positive(CDataObject *x)
+{
+    CDataObject *result;
+    result = (CDataObject *)Py_TYPE(x)->tp_new(x->ob_type, NULL, NULL);
+    if (result != NULL)
+	result->b_value.B = +x->b_value.B;
+    return (PyObject *)result;
+}
+
+
+static PyObject *
+h_add(CDataObject *x, CDataObject *y)
+{
+    CDataObject *result;
+    result = (CDataObject *)Py_TYPE(x)->tp_new(x->ob_type, NULL, NULL);
+    if (result != NULL)
+	result->b_value.h = x->b_value.h + y->b_value.h;
+    return (PyObject *)result;
+}
+
+static PyObject *
+h_subtract(CDataObject *x, CDataObject *y)
+{
+    CDataObject *result;
+    result = (CDataObject *)Py_TYPE(x)->tp_new(x->ob_type, NULL, NULL);
+    if (result != NULL)
+	result->b_value.h = x->b_value.h - y->b_value.h;
+    return (PyObject *)result;
+}
+
+static PyObject *
+h_multiply(CDataObject *x, CDataObject *y)
+{
+    CDataObject *result;
+    result = (CDataObject *)Py_TYPE(x)->tp_new(x->ob_type, NULL, NULL);
+    if (result != NULL)
+	result->b_value.h = x->b_value.h * y->b_value.h;
+    return (PyObject *)result;
+}
+
+static PyObject *
+h_divide(CDataObject *x, CDataObject *y)
+{
+    CDataObject *result;
+    result = (CDataObject *)Py_TYPE(x)->tp_new(x->ob_type, NULL, NULL);
+    if (result != NULL)
+	    result->b_value.h = x->b_value.h / y->b_value.h;
+    return (PyObject *)result;
+}
+
+static PyObject *
+h_remainder(CDataObject *x, CDataObject *y)
+{
+    CDataObject *result;
+    result = (CDataObject *)Py_TYPE(x)->tp_new(x->ob_type, NULL, NULL);
+    if (result != NULL)
+	result->b_value.h = x->b_value.h % y->b_value.h;
+    return (PyObject *)result;
+}
+
+static PyObject *
+h_negative(CDataObject *x)
+{
+    CDataObject *result;
+    result = (CDataObject *)Py_TYPE(x)->tp_new(x->ob_type, NULL, NULL);
+    if (result != NULL)
+	result->b_value.h = -x->b_value.h;
+    return (PyObject *)result;
+}
+
+static PyObject *
+h_positive(CDataObject *x)
+{
+    CDataObject *result;
+    result = (CDataObject *)Py_TYPE(x)->tp_new(x->ob_type, NULL, NULL);
+    if (result != NULL)
+	result->b_value.h = +x->b_value.h;
+    return (PyObject *)result;
+}
+
+
+static PyObject *
+H_add(CDataObject *x, CDataObject *y)
+{
+    CDataObject *result;
+    result = (CDataObject *)Py_TYPE(x)->tp_new(x->ob_type, NULL, NULL);
+    if (result != NULL)
+	result->b_value.H = x->b_value.H + y->b_value.H;
+    return (PyObject *)result;
+}
+
+static PyObject *
+H_subtract(CDataObject *x, CDataObject *y)
+{
+    CDataObject *result;
+    result = (CDataObject *)Py_TYPE(x)->tp_new(x->ob_type, NULL, NULL);
+    if (result != NULL)
+	result->b_value.H = x->b_value.H - y->b_value.H;
+    return (PyObject *)result;
+}
+
+static PyObject *
+H_multiply(CDataObject *x, CDataObject *y)
+{
+    CDataObject *result;
+    result = (CDataObject *)Py_TYPE(x)->tp_new(x->ob_type, NULL, NULL);
+    if (result != NULL)
+	result->b_value.H = x->b_value.H * y->b_value.H;
+    return (PyObject *)result;
+}
+
+static PyObject *
+H_divide(CDataObject *x, CDataObject *y)
+{
+    CDataObject *result;
+    result = (CDataObject *)Py_TYPE(x)->tp_new(x->ob_type, NULL, NULL);
+    if (result != NULL)
+	    result->b_value.H = x->b_value.H / y->b_value.H;
+    return (PyObject *)result;
+}
+
+static PyObject *
+H_remainder(CDataObject *x, CDataObject *y)
+{
+    CDataObject *result;
+    result = (CDataObject *)Py_TYPE(x)->tp_new(x->ob_type, NULL, NULL);
+    if (result != NULL)
+	result->b_value.H = x->b_value.H % y->b_value.H;
+    return (PyObject *)result;
+}
+
+static PyObject *
+H_negative(CDataObject *x)
+{
+    CDataObject *result;
+    result = (CDataObject *)Py_TYPE(x)->tp_new(x->ob_type, NULL, NULL);
+    if (result != NULL)
+	result->b_value.H = -x->b_value.H;
+    return (PyObject *)result;
+}
+
+static PyObject *
+H_positive(CDataObject *x)
+{
+    CDataObject *result;
+    result = (CDataObject *)Py_TYPE(x)->tp_new(x->ob_type, NULL, NULL);
+    if (result != NULL)
+	result->b_value.H = +x->b_value.H;
+    return (PyObject *)result;
+}
+
+
+static PyObject *
+i_add(CDataObject *x, CDataObject *y)
+{
+    CDataObject *result;
+    result = (CDataObject *)Py_TYPE(x)->tp_new(x->ob_type, NULL, NULL);
+    if (result != NULL)
+	result->b_value.i = x->b_value.i + y->b_value.i;
+    return (PyObject *)result;
+}
+
+static PyObject *
+i_subtract(CDataObject *x, CDataObject *y)
+{
+    CDataObject *result;
+    result = (CDataObject *)Py_TYPE(x)->tp_new(x->ob_type, NULL, NULL);
+    if (result != NULL)
+	result->b_value.i = x->b_value.i - y->b_value.i;
+    return (PyObject *)result;
+}
+
+static PyObject *
+i_multiply(CDataObject *x, CDataObject *y)
+{
+    CDataObject *result;
+    result = (CDataObject *)Py_TYPE(x)->tp_new(x->ob_type, NULL, NULL);
+    if (result != NULL)
+	result->b_value.i = x->b_value.i * y->b_value.i;
+    return (PyObject *)result;
+}
+
+static PyObject *
+i_divide(CDataObject *x, CDataObject *y)
+{
+    CDataObject *result;
+    result = (CDataObject *)Py_TYPE(x)->tp_new(x->ob_type, NULL, NULL);
+    if (result != NULL)
+	    result->b_value.i = x->b_value.i / y->b_value.i;
+    return (PyObject *)result;
+}
+
+static PyObject *
+i_remainder(CDataObject *x, CDataObject *y)
+{
+    CDataObject *result;
+    result = (CDataObject *)Py_TYPE(x)->tp_new(x->ob_type, NULL, NULL);
+    if (result != NULL)
+	result->b_value.i = x->b_value.i % y->b_value.i;
+    return (PyObject *)result;
+}
+
+static PyObject *
+i_negative(CDataObject *x)
+{
+    CDataObject *result;
+    result = (CDataObject *)Py_TYPE(x)->tp_new(x->ob_type, NULL, NULL);
+    if (result != NULL)
+	result->b_value.i = -x->b_value.i;
+    return (PyObject *)result;
+}
+
+static PyObject *
+i_positive(CDataObject *x)
+{
+    CDataObject *result;
+    result = (CDataObject *)Py_TYPE(x)->tp_new(x->ob_type, NULL, NULL);
+    if (result != NULL)
+	result->b_value.i = +x->b_value.i;
+    return (PyObject *)result;
+}
+
+
+static PyObject *
+I_add(CDataObject *x, CDataObject *y)
+{
+    CDataObject *result;
+    result = (CDataObject *)Py_TYPE(x)->tp_new(x->ob_type, NULL, NULL);
+    if (result != NULL)
+	result->b_value.I = x->b_value.I + y->b_value.I;
+    return (PyObject *)result;
+}
+
+static PyObject *
+I_subtract(CDataObject *x, CDataObject *y)
+{
+    CDataObject *result;
+    result = (CDataObject *)Py_TYPE(x)->tp_new(x->ob_type, NULL, NULL);
+    if (result != NULL)
+	result->b_value.I = x->b_value.I - y->b_value.I;
+    return (PyObject *)result;
+}
+
+static PyObject *
+I_multiply(CDataObject *x, CDataObject *y)
+{
+    CDataObject *result;
+    result = (CDataObject *)Py_TYPE(x)->tp_new(x->ob_type, NULL, NULL);
+    if (result != NULL)
+	result->b_value.I = x->b_value.I * y->b_value.I;
+    return (PyObject *)result;
+}
+
+static PyObject *
+I_divide(CDataObject *x, CDataObject *y)
+{
+    CDataObject *result;
+    result = (CDataObject *)Py_TYPE(x)->tp_new(x->ob_type, NULL, NULL);
+    if (result != NULL)
+	    result->b_value.I = x->b_value.I / y->b_value.I;
+    return (PyObject *)result;
+}
+
+static PyObject *
+I_remainder(CDataObject *x, CDataObject *y)
+{
+    CDataObject *result;
+    result = (CDataObject *)Py_TYPE(x)->tp_new(x->ob_type, NULL, NULL);
+    if (result != NULL)
+	result->b_value.I = x->b_value.I %  y->b_value.I;
+    return (PyObject *)result;
+}
+
+static PyObject *
+I_negative(CDataObject *x)
+{
+    CDataObject *result;
+    result = (CDataObject *)Py_TYPE(x)->tp_new(x->ob_type, NULL, NULL);
+    if (result != NULL)
+	result->b_value.I = -x->b_value.I;
+    return (PyObject *)result;
+}
+
+static PyObject *
+I_positive(CDataObject *x)
+{
+    CDataObject *result;
+    result = (CDataObject *)Py_TYPE(x)->tp_new(x->ob_type, NULL, NULL);
+    if (result != NULL)
+	result->b_value.I = +x->b_value.I;
+    return (PyObject *)result;
+}
+
+
+static PyObject *
+l_add(CDataObject *x, CDataObject *y)
+{
+    CDataObject *result;
+    result = (CDataObject *)Py_TYPE(x)->tp_new(x->ob_type, NULL, NULL);
+    if (result != NULL)
+	result->b_value.l = x->b_value.l + y->b_value.l;
+    return (PyObject *)result;
+}
+
+static PyObject *
+l_subtract(CDataObject *x, CDataObject *y)
+{
+    CDataObject *result;
+    result = (CDataObject *)Py_TYPE(x)->tp_new(x->ob_type, NULL, NULL);
+    if (result != NULL)
+	result->b_value.l = x->b_value.l - y->b_value.l;
+    return (PyObject *)result;
+}
+
+static PyObject *
+l_multiply(CDataObject *x, CDataObject *y)
+{
+    CDataObject *result;
+    result = (CDataObject *)Py_TYPE(x)->tp_new(x->ob_type, NULL, NULL);
+    if (result != NULL)
+	result->b_value.l = x->b_value.l * y->b_value.l;
+    return (PyObject *)result;
+}
+
+static PyObject *
+l_divide(CDataObject *x, CDataObject *y)
+{
+    CDataObject *result;
+    result = (CDataObject *)Py_TYPE(x)->tp_new(x->ob_type, NULL, NULL);
+    if (result != NULL)
+	    result->b_value.l = x->b_value.l / y->b_value.l;
+    return (PyObject *)result;
+}
+
+static PyObject *
+l_remainder(CDataObject *x, CDataObject *y)
+{
+    CDataObject *result;
+    result = (CDataObject *)Py_TYPE(x)->tp_new(x->ob_type, NULL, NULL);
+    if (result != NULL)
+	result->b_value.l = x->b_value.l % y->b_value.l;
+    return (PyObject *)result;
+}
+
+static PyObject *
+l_negative(CDataObject *x)
+{
+    CDataObject *result;
+    result = (CDataObject *)Py_TYPE(x)->tp_new(x->ob_type, NULL, NULL);
+    if (result != NULL)
+	result->b_value.l = -x->b_value.l;
+    return (PyObject *)result;
+}
+
+static PyObject *
+l_positive(CDataObject *x)
+{
+    CDataObject *result;
+    result = (CDataObject *)Py_TYPE(x)->tp_new(x->ob_type, NULL, NULL);
+    if (result != NULL)
+	result->b_value.l = +x->b_value.l;
+    return (PyObject *)result;
+}
+
+
+static PyObject *
+L_add(CDataObject *x, CDataObject *y)
+{
+    CDataObject *result;
+    result = (CDataObject *)Py_TYPE(x)->tp_new(x->ob_type, NULL, NULL);
+    if (result != NULL)
+	result->b_value.L = x->b_value.L + y->b_value.L;
+    return (PyObject *)result;
+}
+
+static PyObject *
+L_subtract(CDataObject *x, CDataObject *y)
+{
+    CDataObject *result;
+    result = (CDataObject *)Py_TYPE(x)->tp_new(x->ob_type, NULL, NULL);
+    if (result != NULL)
+	result->b_value.L = x->b_value.L - y->b_value.L;
+    return (PyObject *)result;
+}
+
+static PyObject *
+L_multiply(CDataObject *x, CDataObject *y)
+{
+    CDataObject *result;
+    result = (CDataObject *)Py_TYPE(x)->tp_new(x->ob_type, NULL, NULL);
+    if (result != NULL)
+	result->b_value.L = x->b_value.L * y->b_value.L;
+    return (PyObject *)result;
+}
+
+static PyObject *
+L_divide(CDataObject *x, CDataObject *y)
+{
+    CDataObject *result;
+    result = (CDataObject *)Py_TYPE(x)->tp_new(x->ob_type, NULL, NULL);
+    if (result != NULL)
+	    result->b_value.L = x->b_value.L / y->b_value.L;
+    return (PyObject *)result;
+}
+
+static PyObject *
+L_remainder(CDataObject *x, CDataObject *y)
+{
+    CDataObject *result;
+    result = (CDataObject *)Py_TYPE(x)->tp_new(x->ob_type, NULL, NULL);
+    if (result != NULL)
+	result->b_value.L = x->b_value.L % y->b_value.L;
+    return (PyObject *)result;
+}
+
+static PyObject *
+L_negative(CDataObject *x)
+{
+    CDataObject *result;
+    result = (CDataObject *)Py_TYPE(x)->tp_new(x->ob_type, NULL, NULL);
+    if (result != NULL)
+	result->b_value.L = -x->b_value.L;
+    return (PyObject *)result;
+}
+
+static PyObject *
+L_positive(CDataObject *x)
+{
+    CDataObject *result;
+    result = (CDataObject *)Py_TYPE(x)->tp_new(x->ob_type, NULL, NULL);
+    if (result != NULL)
+	result->b_value.L = +x->b_value.L;
+    return (PyObject *)result;
+}
+
+
+static PyObject *
+d_add(CDataObject *x, CDataObject *y)
+{
+    CDataObject *result;
+    result = (CDataObject *)Py_TYPE(x)->tp_new(x->ob_type, NULL, NULL);
+    if (result != NULL)
+	result->b_value.d = x->b_value.d + y->b_value.d;
+    return (PyObject *)result;
+}
+
+static PyObject *
+d_subtract(CDataObject *x, CDataObject *y)
+{
+    CDataObject *result;
+    result = (CDataObject *)Py_TYPE(x)->tp_new(x->ob_type, NULL, NULL);
+    if (result != NULL)
+	result->b_value.d = x->b_value.d - y->b_value.d;
+    return (PyObject *)result;
+}
+
+static PyObject *
+d_multiply(CDataObject *x, CDataObject *y)
+{
+    CDataObject *result;
+    result = (CDataObject *)Py_TYPE(x)->tp_new(x->ob_type, NULL, NULL);
+    if (result != NULL)
+	result->b_value.d = x->b_value.d * y->b_value.d;
+    return (PyObject *)result;
+}
+
+static PyObject *
+d_divide(CDataObject *x, CDataObject *y)
+{
+    CDataObject *result;
+    result = (CDataObject *)Py_TYPE(x)->tp_new(x->ob_type, NULL, NULL);
+    if (result != NULL)
+	    result->b_value.d = x->b_value.d / y->b_value.d;
+    return (PyObject *)result;
+}
+
+static PyObject *
+d_remainder(CDataObject *x, CDataObject *y)
+{
+    CDataObject *result;
+    result = (CDataObject *)Py_TYPE(x)->tp_new(x->ob_type, NULL, NULL);
+    if (result != NULL)
+	result->b_value.d = fmod(x->b_value.d, y->b_value.d);
+    return (PyObject *)result;
+}
+
+static PyObject *
+d_negative(CDataObject *x)
+{
+    CDataObject *result;
+    result = (CDataObject *)Py_TYPE(x)->tp_new(x->ob_type, NULL, NULL);
+    if (result != NULL)
+	result->b_value.d = -x->b_value.d;
+    return (PyObject *)result;
+}
+
+static PyObject *
+d_positive(CDataObject *x)
+{
+    CDataObject *result;
+    result = (CDataObject *)Py_TYPE(x)->tp_new(x->ob_type, NULL, NULL);
+    if (result != NULL)
+	result->b_value.d = +x->b_value.d;
+    return (PyObject *)result;
+}
+
+
+static PyObject *
+f_add(CDataObject *x, CDataObject *y)
+{
+    CDataObject *result;
+    result = (CDataObject *)Py_TYPE(x)->tp_new(x->ob_type, NULL, NULL);
+    if (result != NULL)
+	result->b_value.f = x->b_value.f + y->b_value.f;
+    return (PyObject *)result;
+}
+
+static PyObject *
+f_subtract(CDataObject *x, CDataObject *y)
+{
+    CDataObject *result;
+    result = (CDataObject *)Py_TYPE(x)->tp_new(x->ob_type, NULL, NULL);
+    if (result != NULL)
+	result->b_value.f = x->b_value.f - y->b_value.f;
+    return (PyObject *)result;
+}
+
+static PyObject *
+f_multiply(CDataObject *x, CDataObject *y)
+{
+    CDataObject *result;
+    result = (CDataObject *)Py_TYPE(x)->tp_new(x->ob_type, NULL, NULL);
+    if (result != NULL)
+	result->b_value.f = x->b_value.f * y->b_value.f;
+    return (PyObject *)result;
+}
+
+static PyObject *
+f_divide(CDataObject *x, CDataObject *y)
+{
+    CDataObject *result;
+    result = (CDataObject *)Py_TYPE(x)->tp_new(x->ob_type, NULL, NULL);
+    if (result != NULL)
+	    result->b_value.f = x->b_value.f / y->b_value.f;
+    return (PyObject *)result;
+}
+
+static PyObject *
+f_remainder(CDataObject *x, CDataObject *y)
+{
+    CDataObject *result;
+    result = (CDataObject *)Py_TYPE(x)->tp_new(x->ob_type, NULL, NULL);
+    if (result != NULL)
+	result->b_value.f = fmodf(x->b_value.f, y->b_value.f);
+    return (PyObject *)result;
+}
+
+static PyObject *
+f_negative(CDataObject *x)
+{
+    CDataObject *result;
+    result = (CDataObject *)Py_TYPE(x)->tp_new(x->ob_type, NULL, NULL);
+    if (result != NULL)
+	result->b_value.f = -x->b_value.f;
+    return (PyObject *)result;
+}
+
+static PyObject *
+f_positive(CDataObject *x)
+{
+    CDataObject *result;
+    result = (CDataObject *)Py_TYPE(x)->tp_new(x->ob_type, NULL, NULL);
+    if (result != NULL)
+	result->b_value.f = +x->b_value.f;
+    return (PyObject *)result;
+}
+
+static PyObject *
+g_add(CDataObject *x, CDataObject *y)
+{
+    CDataObject *result;
+    result = (CDataObject *)Py_TYPE(x)->tp_new(x->ob_type, NULL, NULL);
+    if (result != NULL)
+	result->b_value.g = x->b_value.g + y->b_value.g;
+    return (PyObject *)result;
+}
+
+static PyObject *
+g_subtract(CDataObject *x, CDataObject *y)
+{
+    CDataObject *result;
+    result = (CDataObject *)Py_TYPE(x)->tp_new(x->ob_type, NULL, NULL);
+    if (result != NULL)
+	result->b_value.g = x->b_value.g - y->b_value.g;
+    return (PyObject *)result;
+}
+
+static PyObject *
+g_multiply(CDataObject *x, CDataObject *y)
+{
+    CDataObject *result;
+    result = (CDataObject *)Py_TYPE(x)->tp_new(x->ob_type, NULL, NULL);
+    if (result != NULL)
+	result->b_value.g = x->b_value.g * y->b_value.g;
+    return (PyObject *)result;
+}
+
+static PyObject *
+g_divide(CDataObject *x, CDataObject *y)
+{
+    CDataObject *result;
+    result = (CDataObject *)Py_TYPE(x)->tp_new(x->ob_type, NULL, NULL);
+    if (result != NULL)
+	    result->b_value.g = x->b_value.g / y->b_value.g;
+    return (PyObject *)result;
+}
+
+static PyObject *
+g_remainder(CDataObject *x, CDataObject *y)
+{
+    CDataObject *result;
+    result = (CDataObject *)Py_TYPE(x)->tp_new(x->ob_type, NULL, NULL);
+    if (result != NULL)
+	result->b_value.g = fmodl(x->b_value.g, y->b_value.g);
+    return (PyObject *)result;
+}
+
+static PyObject *
+g_negative(CDataObject *x)
+{
+    CDataObject *result;
+    result = (CDataObject *)Py_TYPE(x)->tp_new(x->ob_type, NULL, NULL);
+    if (result != NULL)
+	result->b_value.g = -x->b_value.g;
+    return (PyObject *)result;
+}
+
+static PyObject *
+g_positive(CDataObject *x)
+{
+    CDataObject *result;
+    result = (CDataObject *)Py_TYPE(x)->tp_new(x->ob_type, NULL, NULL);
+    if (result != NULL)
+	result->b_value.g = +x->b_value.g;
+    return (PyObject *)result;
+}
+
+
+struct tableentry {
+    char code;
+    PyNumberMethods methods;
+};
+
+struct tableentry
+number_methods_table[] = {
+    {'b',
+     {
+	 (binaryfunc)b_add, /* nb_add */
+	 (binaryfunc)b_subtract, /* nb_subtract */
+	 (binaryfunc)b_multiply, /* nb_multiply */
+	 (binaryfunc)b_divide, /* nb_divide */
+	 (binaryfunc)b_remainder, /* nb_remainder */
+	 (binaryfunc)0, /* nb_divmod */
+	 (ternaryfunc)0, /* nb_power */
+	 (unaryfunc)b_negative, /* nb_negative */
+	 (unaryfunc)b_positive, /* nb_positive */
+	 (unaryfunc)0, /* nb_absolute */
+	 (inquiry)0, /* nb_nonzero */
+     }
+    },
+    {'B',
+     {
+	 (binaryfunc)B_add, /* nb_add */
+	 (binaryfunc)B_subtract, /* nb_subtract */
+	 (binaryfunc)B_multiply, /* nb_multiply */
+	 (binaryfunc)B_divide, /* nb_divide */
+	 (binaryfunc)B_remainder, /* nb_remainder */
+	 (binaryfunc)0, /* nb_divmod */
+	 (ternaryfunc)0, /* nb_power */
+	 (unaryfunc)B_negative, /* nb_negative */
+	 (unaryfunc)B_positive, /* nb_positive */
+	 (unaryfunc)0, /* nb_absolute */
+	 (inquiry)0, /* nb_nonzero */
+     }
+    },
+    {'h',
+     {
+	 (binaryfunc)h_add, /* nb_add */
+	 (binaryfunc)h_subtract, /* nb_subtract */
+	 (binaryfunc)h_multiply, /* nb_multiply */
+	 (binaryfunc)h_divide, /* nb_divide */
+	 (binaryfunc)h_remainder, /* nb_remainder */
+	 (binaryfunc)0, /* nb_divmod */
+	 (ternaryfunc)0, /* nb_power */
+	 (unaryfunc)h_negative, /* nb_negative */
+	 (unaryfunc)h_positive, /* nb_positive */
+	 (unaryfunc)0, /* nb_absolute */
+	 (inquiry)0, /* nb_nonzero */
+     }
+    },
+    {'H',
+     {
+	 (binaryfunc)H_add, /* nb_add */
+	 (binaryfunc)H_subtract, /* nb_subtract */
+	 (binaryfunc)H_multiply, /* nb_multiply */
+	 (binaryfunc)H_divide, /* nb_divide */
+	 (binaryfunc)H_remainder, /* nb_remainder */
+	 (binaryfunc)0, /* nb_divmod */
+	 (ternaryfunc)0, /* nb_power */
+	 (unaryfunc)H_negative, /* nb_negative */
+	 (unaryfunc)H_positive, /* nb_positive */
+	 (unaryfunc)0, /* nb_absolute */
+	 (inquiry)0, /* nb_nonzero */
+     }
+    },
+    {'i',
+     {
+	 (binaryfunc)i_add, /* nb_add */
+	 (binaryfunc)i_subtract, /* nb_subtract */
+	 (binaryfunc)i_multiply, /* nb_multiply */
+	 (binaryfunc)i_divide, /* nb_divide */
+	 (binaryfunc)i_remainder, /* nb_remainder */
+	 (binaryfunc)0, /* nb_divmod */
+	 (ternaryfunc)0, /* nb_power */
+	 (unaryfunc)i_negative, /* nb_negative */
+	 (unaryfunc)i_positive, /* nb_positive */
+	 (unaryfunc)0, /* nb_absolute */
+	 (inquiry)0, /* nb_nonzero */
+     }
+    },
+    {'I',
+     {
+	 (binaryfunc)I_add, /* nb_add */
+	 (binaryfunc)I_subtract, /* nb_subtract */
+	 (binaryfunc)I_multiply, /* nb_multiply */
+	 (binaryfunc)I_divide, /* nb_divide */
+	 (binaryfunc)I_remainder, /* nb_remainder */
+	 (binaryfunc)0, /* nb_divmod */
+	 (ternaryfunc)0, /* nb_power */
+	 (unaryfunc)I_negative, /* nb_negative */
+	 (unaryfunc)I_positive, /* nb_positive */
+	 (unaryfunc)0, /* nb_absolute */
+	 (inquiry)0, /* nb_nonzero */
+     }
+    },
+    {'l',
+     {
+	 (binaryfunc)l_add, /* nb_add */
+	 (binaryfunc)l_subtract, /* nb_subtract */
+	 (binaryfunc)l_multiply, /* nb_multiply */
+	 (binaryfunc)l_divide, /* nb_divide */
+	 (binaryfunc)l_remainder, /* nb_remainder */
+	 (binaryfunc)0, /* nb_divmod */
+	 (ternaryfunc)0, /* nb_power */
+	 (unaryfunc)l_negative, /* nb_negative */
+	 (unaryfunc)l_positive, /* nb_positive */
+	 (unaryfunc)0, /* nb_absolute */
+	 (inquiry)0, /* nb_nonzero */
+     }
+    },
+    {'L',
+     {
+	 (binaryfunc)L_add, /* nb_add */
+	 (binaryfunc)L_subtract, /* nb_subtract */
+	 (binaryfunc)L_multiply, /* nb_multiply */
+	 (binaryfunc)L_divide, /* nb_divide */
+	 (binaryfunc)L_remainder, /* nb_remainder */
+	 (binaryfunc)0, /* nb_divmod */
+	 (ternaryfunc)0, /* nb_power */
+	 (unaryfunc)L_negative, /* nb_negative */
+	 (unaryfunc)L_positive, /* nb_positive */
+	 (unaryfunc)0, /* nb_absolute */
+	 (inquiry)0, /* nb_nonzero */
+     }
+    },
+    {'d',
+     {
+	 (binaryfunc)d_add, /* nb_add */
+	 (binaryfunc)d_subtract, /* nb_subtract */
+	 (binaryfunc)d_multiply, /* nb_multiply */
+	 (binaryfunc)d_divide, /* nb_divide */
+	 (binaryfunc)d_remainder, /* nb_remainder */
+	 (binaryfunc)0, /* nb_divmod */
+	 (ternaryfunc)0, /* nb_power */
+	 (unaryfunc)d_negative, /* nb_negative */
+	 (unaryfunc)d_positive, /* nb_positive */
+	 (unaryfunc)0, /* nb_absolute */
+	 (inquiry)0, /* nb_nonzero */
+     }
+    },
+    {'f',
+     {
+	 (binaryfunc)f_add, /* nb_add */
+	 (binaryfunc)f_subtract, /* nb_subtract */
+	 (binaryfunc)f_multiply, /* nb_multiply */
+	 (binaryfunc)f_divide, /* nb_divide */
+	 (binaryfunc)f_remainder, /* nb_remainder */
+	 (binaryfunc)0, /* nb_divmod */
+	 (ternaryfunc)0, /* nb_power */
+	 (unaryfunc)f_negative, /* nb_negative */
+	 (unaryfunc)f_positive, /* nb_positive */
+	 (unaryfunc)0, /* nb_absolute */
+	 (inquiry)0, /* nb_nonzero */
+     }
+    },
+    {'g',
+     {
+	 (binaryfunc)g_add, /* nb_add */
+	 (binaryfunc)g_subtract, /* nb_subtract */
+	 (binaryfunc)g_multiply, /* nb_multiply */
+	 (binaryfunc)g_divide, /* nb_divide */
+	 (binaryfunc)g_remainder, /* nb_remainder */
+	 (binaryfunc)0, /* nb_divmod */
+	 (ternaryfunc)0, /* nb_power */
+	 (unaryfunc)g_negative, /* nb_negative */
+	 (unaryfunc)g_positive, /* nb_positive */
+	 (unaryfunc)0, /* nb_absolute */
+	 (inquiry)0, /* nb_nonzero */
+     }
+    },
+    {0, {0}} /* centinel */
+};
+
+PyNumberMethods *
+_PyCData_NumberMethods(const char *proto)
+{
+    struct tableentry *entry;
+
+    for (entry = number_methods_table; entry->code; ++entry) {
+	if (entry->code == *proto)
+	    return &entry->methods;
+    }
+    return NULL;
+}