Index: Objects/complexobject.c
===================================================================
--- Objects/complexobject.c	(revision 81284)
+++ Objects/complexobject.c	(working copy)
@@ -620,22 +620,54 @@
 complex_richcompare(PyObject *v, PyObject *w, int op)
 {
     PyObject *res;
-    Py_complex i, j;
+    Py_complex i;
+    int equal;
+
+    assert(PyComplex_Check(v));
     TO_COMPLEX(v, i);
-    TO_COMPLEX(w, j);
 
     if (op != Py_EQ && op != Py_NE) {
-        Py_INCREF(Py_NotImplemented);
-        return Py_NotImplemented;
+        goto Unimplemented;
     }
 
-    if ((i.real == j.real && i.imag == j.imag) == (op == Py_EQ))
-        res = Py_True;
+    if (PyLong_Check(w)) {
+        PyObject *j = NULL;
+        PyObject *sub_res = NULL;
+
+        j = PyFloat_FromDouble(i.real);
+        if (j == NULL)
+            return NULL;
+
+        sub_res = PyObject_RichCompare(j, w, Py_EQ);
+        if (sub_res == NULL)
+            return NULL;
+       
+        equal = (sub_res == Py_True && i.imag == 0.0);
+        Py_DECREF(sub_res);
+    } else if (PyFloat_Check(w)) {
+        double j = PyFloat_AsDouble(w);
+
+        equal = (i.real == j && i.imag == 0.0);
+    } else if (PyComplex_Check(w)) {
+        Py_complex j;
+
+        TO_COMPLEX(w, j);
+        equal = (i.real == j.real && i.imag == j.imag);
+    } else {
+        goto Unimplemented;
+    }
+
+    if (equal == (op == Py_EQ))
+         res = Py_True;
     else
-        res = Py_False;
+         res = Py_False;
 
     Py_INCREF(res);
     return res;
+
+Unimplemented:
+    Py_INCREF(Py_NotImplemented);
+    return Py_NotImplemented;
 }
 
 static PyObject *
Index: Lib/test/test_complex.py
===================================================================
--- Lib/test/test_complex.py	(revision 81284)
+++ Lib/test/test_complex.py	(working copy)
@@ -110,7 +110,9 @@
         self.assertRaises(TypeError, complex.__floordiv__, 3+0j, 0+0j)
 
     def test_richcompare(self):
-        self.assertRaises(OverflowError, complex.__eq__, 1+1j, 1<<10000)
+        self.assertIs(complex.__eq__(1+1j, 1<<10000), False)
+        self.assertIs(complex.__eq__(complex(2**53+1), 2**53+1), False)
+        self.assertIs(complex.__ne__(complex(2**53+1), 2**53+1), True)
         self.assertIs(complex.__lt__(1+1j, None), NotImplemented)
         self.assertIs(complex.__eq__(1+1j, 1+1j), True)
         self.assertIs(complex.__eq__(1+1j, 2+2j), False)