diff --git a/Lib/test/list_tests.py b/Lib/test/list_tests.py
index fc1a6c3..3867be5 100644
--- a/Lib/test/list_tests.py
+++ b/Lib/test/list_tests.py
@@ -99,16 +99,16 @@
         self.assertRaises(TypeError, a.__setitem__)
 
         a = self.type2test([0,1,2,3,4])
-        a[0L] = 1
-        a[1L] = 2
-        a[2L] = 3
+        a[0] = 1
+        a[1] = 2
+        a[2] = 3
         self.assertEqual(a, self.type2test([1,2,3,3,4]))
         a[0] = 5
         a[1] = 6
         a[2] = 7
         self.assertEqual(a, self.type2test([5,6,7,3,4]))
-        a[-2L] = 88
-        a[-1L] = 99
+        a[-2] = 88
+        a[-1] = 99
         self.assertEqual(a, self.type2test([5,6,7,88,99]))
         a[-2] = 8
         a[-1] = 9
@@ -189,8 +189,8 @@
         self.assertEqual(a, self.type2test([]))
 
         a = self.type2test([0, 1])
-        del a[1L:2L]
-        del a[0L:1L]
+        del a[1:2]
+        del a[0:1]
         self.assertEqual(a, self.type2test([]))
 
         a = self.type2test([0, 1])
@@ -198,7 +198,7 @@
         self.assertEqual(a, self.type2test([1]))
 
         a = self.type2test([0, 1])
-        del a[-2L:-1L]
+        del a[-2:-1]
         self.assertEqual(a, self.type2test([1]))
 
         a = self.type2test([0, 1])
@@ -207,8 +207,8 @@
         self.assertEqual(a, self.type2test([]))
 
         a = self.type2test([0, 1])
-        del a[1L:]
-        del a[:1L]
+        del a[1:]
+        del a[:1]
         self.assertEqual(a, self.type2test([]))
 
         a = self.type2test([0, 1])
@@ -216,7 +216,7 @@
         self.assertEqual(a, self.type2test([0]))
 
         a = self.type2test([0, 1])
-        del a[-1L:]
+        del a[-1:]
         self.assertEqual(a, self.type2test([0]))
 
         a = self.type2test([0, 1])
diff --git a/Lib/test/mapping_tests.py b/Lib/test/mapping_tests.py
index 15f9add..6b872c4 100644
--- a/Lib/test/mapping_tests.py
+++ b/Lib/test/mapping_tests.py
@@ -526,7 +526,7 @@
 
         # verify longs/ints get same value when key > 32 bits (for 64-bit archs)
         # see SF bug #689659
-        x = 4503599627370496L
+        x = 4503599627370496
         y = 4503599627370496
         h = self._full_mapping({x: 'anything', y: 'something else'})
         self.assertEqual(h[x], h[y])
@@ -626,7 +626,7 @@
     def test_eq(self):
         self.assertEqual(self._empty_mapping(), self._empty_mapping())
         self.assertEqual(self._full_mapping({1: 2}),
-                         self._full_mapping({1L: 2L}))
+                         self._full_mapping({1: 2}))
 
         class Exc(Exception): pass
 
diff --git a/Lib/test/pickletester.py b/Lib/test/pickletester.py
index 0f1386e..5d340b3 100644
--- a/Lib/test/pickletester.py
+++ b/Lib/test/pickletester.py
@@ -349,7 +349,7 @@
     c = C()
     c.foo = 1
     c.bar = 2
-    x = [0, 1L, 2.0, 3.0+0j]
+    x = [0, 1, 2.0, 3.0+0j]
     # Append some integer test cases at cPickle.c's internal size
     # cutoffs.
     uint1max = 0xff
@@ -504,7 +504,7 @@
                 n = n >> 1
 
     def test_maxint64(self):
-        maxint64 = (1L << 63) - 1
+        maxint64 = (1 << 63) - 1
         data = 'I' + str(maxint64) + '\n.'
         got = self.loads(data)
         self.assertEqual(got, maxint64)
@@ -517,7 +517,7 @@
         for proto in protocols:
             # 256 bytes is where LONG4 begins.
             for nbits in 1, 8, 8*254, 8*255, 8*256, 8*257:
-                nbase = 1L << nbits
+                nbase = 1 << nbits
                 for npos in nbase-1, nbase, nbase+1:
                     for n in npos, -npos:
                         pickle = self.dumps(n, proto)
@@ -525,7 +525,7 @@
                         self.assertEqual(n, got)
         # Try a monster.  This is quadratic-time in protos 0 & 1, so don't
         # bother with those.
-        nbase = long("deadbeeffeedface", 16)
+        nbase = int("deadbeeffeedface", 16)
         nbase += nbase << 1000000
         for n in nbase, -nbase:
             p = self.dumps(n, 2)
@@ -592,7 +592,7 @@
             self.fail("expected bad protocol number to raise ValueError")
 
     def test_long1(self):
-        x = 12345678910111213141516178920L
+        x = 12345678910111213141516178920
         for proto in protocols:
             s = self.dumps(x, proto)
             y = self.loads(s)
@@ -600,7 +600,7 @@
             self.assertEqual(opcode_in_pickle(pickle.LONG1, s), proto >= 2)
 
     def test_long4(self):
-        x = 12345678910111213141516178920L << (256*8)
+        x = 12345678910111213141516178920 << (256*8)
         for proto in protocols:
             s = self.dumps(x, proto)
             y = self.loads(s)
@@ -864,8 +864,8 @@
 class MyInt(int):
     sample = 1
 
-class MyLong(long):
-    sample = 1L
+class MyLong(int):
+    sample = 1
 
 class MyFloat(float):
     sample = 1.0
diff --git a/Lib/test/regrtest.py b/Lib/test/regrtest.py
index ce39649..4517c59 100755
--- a/Lib/test/regrtest.py
+++ b/Lib/test/regrtest.py
@@ -1324,7 +1324,7 @@
             if test_timeout.skip_expected:
                 self.expected.add('test_timeout')
 
-            if sys.maxint == 9223372036854775807L:
+            if sys.maxint == 9223372036854775807:
                 self.expected.add('test_rgbimg')
                 self.expected.add('test_imageop')
 
diff --git a/Lib/test/seq_tests.py b/Lib/test/seq_tests.py
index 18fb3b7..0dfe7e4 100644
--- a/Lib/test/seq_tests.py
+++ b/Lib/test/seq_tests.py
@@ -138,10 +138,10 @@
         u = self.type2test([0, 1, 2, 3, 4])
         for i in xrange(len(u)):
             self.assertEqual(u[i], i)
-            self.assertEqual(u[long(i)], i)
+            self.assertEqual(u[int(i)], i)
         for i in xrange(-len(u), -1):
             self.assertEqual(u[i], len(u)+i)
-            self.assertEqual(u[long(i)], len(u)+i)
+            self.assertEqual(u[int(i)], len(u)+i)
         self.assertRaises(IndexError, u.__getitem__, -len(u)-1)
         self.assertRaises(IndexError, u.__getitem__, len(u))
         self.assertRaises(ValueError, u.__getitem__, slice(0,10,0))
@@ -189,12 +189,12 @@
         self.assertEqual(u[-100:100:], u)
         self.assertEqual(u[100:-100:-1], u[::-1])
         self.assertEqual(u[-100:100:-1], self.type2test([]))
-        self.assertEqual(u[-100L:100L:2L], self.type2test([0, 2, 4]))
+        self.assertEqual(u[-100:100:2], self.type2test([0, 2, 4]))
 
         # Test extreme cases with long ints
         a = self.type2test([0,1,2,3,4])
-        self.assertEqual(a[ -pow(2,128L): 3 ], self.type2test([0,1,2]))
-        self.assertEqual(a[ 3: pow(2,145L) ], self.type2test([3,4]))
+        self.assertEqual(a[ -pow(2,128): 3 ], self.type2test([0,1,2]))
+        self.assertEqual(a[ 3: pow(2,145) ], self.type2test([3,4]))
 
         self.assertRaises(TypeError, u.__getslice__)
 
@@ -254,16 +254,16 @@
         self.assertEqual(self.type2test([-1]) + u1, self.type2test([-1, 0]))
         self.assertEqual(self.type2test(), u2*0)
         self.assertEqual(self.type2test(), 0*u2)
-        self.assertEqual(self.type2test(), u2*0L)
-        self.assertEqual(self.type2test(), 0L*u2)
+        self.assertEqual(self.type2test(), u2*0)
+        self.assertEqual(self.type2test(), 0*u2)
         self.assertEqual(u2, u2*1)
         self.assertEqual(u2, 1*u2)
-        self.assertEqual(u2, u2*1L)
-        self.assertEqual(u2, 1L*u2)
+        self.assertEqual(u2, u2*1)
+        self.assertEqual(u2, 1*u2)
         self.assertEqual(u2+u2, u2*2)
         self.assertEqual(u2+u2, 2*u2)
-        self.assertEqual(u2+u2, u2*2L)
-        self.assertEqual(u2+u2, 2L*u2)
+        self.assertEqual(u2+u2, u2*2)
+        self.assertEqual(u2+u2, 2*u2)
         self.assertEqual(u2+u2+u2, u2*3)
         self.assertEqual(u2+u2+u2, 3*u2)
 
@@ -308,10 +308,10 @@
 
     def test_subscript(self):
         a = self.type2test([10, 11])
-        self.assertEqual(a.__getitem__(0L), 10)
-        self.assertEqual(a.__getitem__(1L), 11)
-        self.assertEqual(a.__getitem__(-2L), 10)
-        self.assertEqual(a.__getitem__(-1L), 11)
+        self.assertEqual(a.__getitem__(0), 10)
+        self.assertEqual(a.__getitem__(1), 11)
+        self.assertEqual(a.__getitem__(-2), 10)
+        self.assertEqual(a.__getitem__(-1), 11)
         self.assertRaises(IndexError, a.__getitem__, -3)
         self.assertRaises(IndexError, a.__getitem__, 3)
         self.assertEqual(a.__getitem__(slice(0,1)), self.type2test([10]))
diff --git a/Lib/test/string_tests.py b/Lib/test/string_tests.py
index 2116ea4..17e3389 100644
--- a/Lib/test/string_tests.py
+++ b/Lib/test/string_tests.py
@@ -12,7 +12,7 @@
     def __getitem__(self, i): return self.seq[i]
 
 class BadSeq1(Sequence):
-    def __init__(self): self.seq = [7, 'hello', 123L]
+    def __init__(self): self.seq = [7, 'hello', 123]
 
 class BadSeq2(Sequence):
     def __init__(self): self.seq = ['a', 'b', 'c']
@@ -902,7 +902,7 @@
     def test_subscript(self):
         self.checkequal(u'a', 'abc', '__getitem__', 0)
         self.checkequal(u'c', 'abc', '__getitem__', -1)
-        self.checkequal(u'a', 'abc', '__getitem__', 0L)
+        self.checkequal(u'a', 'abc', '__getitem__', 0)
         self.checkequal(u'abc', 'abc', '__getitem__', slice(0, 3))
         self.checkequal(u'abc', 'abc', '__getitem__', slice(0, 1000))
         self.checkequal(u'a', 'abc', '__getitem__', slice(0, 1))
@@ -965,7 +965,7 @@
 
         self.checkraises(TypeError, ' ', 'join')
         self.checkraises(TypeError, ' ', 'join', 7)
-        self.checkraises(TypeError, ' ', 'join', Sequence([7, 'hello', 123L]))
+        self.checkraises(TypeError, ' ', 'join', Sequence([7, 'hello', 123]))
         try:
             def f():
                 yield 4 + ""
diff --git a/Lib/test/test_array.py b/Lib/test/test_array.py
index 5c79b48..17d494c 100755
--- a/Lib/test/test_array.py
+++ b/Lib/test/test_array.py
@@ -61,7 +61,7 @@
         bi = a.buffer_info()
         self.assert_(isinstance(bi, tuple))
         self.assertEqual(len(bi), 2)
-        self.assert_(isinstance(bi[0], (int, long)))
+        self.assert_(isinstance(bi[0], (int, int)))
         self.assert_(isinstance(bi[1], int))
         self.assertEqual(bi[1], len(a))
 
@@ -323,9 +323,9 @@
     def test_getitem(self):
         a = array.array(self.typecode, self.example)
         self.assertEntryEqual(a[0], self.example[0])
-        self.assertEntryEqual(a[0L], self.example[0])
+        self.assertEntryEqual(a[0], self.example[0])
         self.assertEntryEqual(a[-1], self.example[-1])
-        self.assertEntryEqual(a[-1L], self.example[-1])
+        self.assertEntryEqual(a[-1], self.example[-1])
         self.assertEntryEqual(a[len(self.example)-1], self.example[-1])
         self.assertEntryEqual(a[-len(self.example)], self.example[0])
         self.assertRaises(TypeError, a.__getitem__)
@@ -338,7 +338,7 @@
         self.assertEntryEqual(a[0], a[-1])
 
         a = array.array(self.typecode, self.example)
-        a[0L] = a[-1]
+        a[0] = a[-1]
         self.assertEntryEqual(a[0], a[-1])
 
         a = array.array(self.typecode, self.example)
@@ -346,7 +346,7 @@
         self.assertEntryEqual(a[0], a[-1])
 
         a = array.array(self.typecode, self.example)
-        a[-1L] = a[0]
+        a[-1] = a[0]
         self.assertEntryEqual(a[0], a[-1])
 
         a = array.array(self.typecode, self.example)
@@ -777,7 +777,7 @@
         self.assertEqual(a[3::-2], array.array(self.typecode, [3,1]))
         self.assertEqual(a[-100:100:], a)
         self.assertEqual(a[100:-100:-1], a[::-1])
-        self.assertEqual(a[-100L:100L:2L], array.array(self.typecode, [0,2,4]))
+        self.assertEqual(a[-100:100:2], array.array(self.typecode, [0,2,4]))
         self.assertEqual(a[1000:2000:2], array.array(self.typecode, []))
         self.assertEqual(a[-1000:-2000:-2], array.array(self.typecode, []))
 
@@ -863,8 +863,8 @@
 
     def test_overflow(self):
         a = array.array(self.typecode)
-        lower = -1 * long(pow(2, a.itemsize * 8 - 1))
-        upper = long(pow(2, a.itemsize * 8 - 1)) - 1L
+        lower = -1 * int(pow(2, a.itemsize * 8 - 1))
+        upper = int(pow(2, a.itemsize * 8 - 1)) - 1
         self.check_overflow(lower, upper)
 
 class UnsignedNumberTest(NumberTest):
@@ -876,7 +876,7 @@
     def test_overflow(self):
         a = array.array(self.typecode)
         lower = 0
-        upper = long(pow(2, a.itemsize * 8)) - 1L
+        upper = int(pow(2, a.itemsize * 8)) - 1
         self.check_overflow(lower, upper)
 
 
diff --git a/Lib/test/test_ast.py b/Lib/test/test_ast.py
index 914f1d9..289b533 100644
--- a/Lib/test/test_ast.py
+++ b/Lib/test/test_ast.py
@@ -2,7 +2,7 @@
 import _ast
 
 def to_tuple(t):
-    if t is None or isinstance(t, (basestring, int, long, complex)):
+    if t is None or isinstance(t, (basestring, int, int, complex)):
         return t
     elif isinstance(t, list):
         return [to_tuple(e) for e in t]
@@ -93,7 +93,7 @@
   # Call
   "f(1,2,c=3,*d,**e)",
   # Num
-  "10L",
+  "10",
   # Str
   "'string'",
   # Attribute
diff --git a/Lib/test/test_asynchat.py b/Lib/test/test_asynchat.py
index 9926167..6bcedd6 100644
--- a/Lib/test/test_asynchat.py
+++ b/Lib/test/test_asynchat.py
@@ -77,7 +77,7 @@
         s = echo_server()
         s.start()
         time.sleep(1) # Give server time to initialize
-        c = echo_client(6L)
+        c = echo_client(6)
         c.push("hello ")
         c.push("world\n")
         asyncore.loop()
diff --git a/Lib/test/test_bigmem.py b/Lib/test/test_bigmem.py
index 6d6c37c..5d2d844 100644
--- a/Lib/test/test_bigmem.py
+++ b/Lib/test/test_bigmem.py
@@ -866,13 +866,13 @@
 
     @bigmemtest(minsize=_2G // 5 + 2, memuse=8 * 5)
     def test_index(self, size):
-        l = [1L, 2L, 3L, 4L, 5L] * size
+        l = [1, 2, 3, 4, 5] * size
         size *= 5
         self.assertEquals(l.index(1), 0)
         self.assertEquals(l.index(5, size - 5), size - 1)
         self.assertEquals(l.index(5, size - 5, size), size - 1)
         self.assertRaises(ValueError, l.index, 1, size - 4, size)
-        self.assertRaises(ValueError, l.index, 6L)
+        self.assertRaises(ValueError, l.index, 6)
 
     # This tests suffers from overallocation, just like test_append.
     @bigmemtest(minsize=_2G + 10, memuse=9)
diff --git a/Lib/test/test_binop.py b/Lib/test/test_binop.py
index ccce207..5aeb118 100644
--- a/Lib/test/test_binop.py
+++ b/Lib/test/test_binop.py
@@ -11,11 +11,11 @@
 
 def isint(x):
     """Test whether an object is an instance of int or long."""
-    return isinstance(x, int) or isinstance(x, long)
+    return isinstance(x, int) or isinstance(x, int)
 
 def isnum(x):
     """Test whether an object is an instance of a built-in numeric type."""
-    for T in int, long, float, complex:
+    for T in int, int, float, complex:
         if isinstance(x, T):
             return 1
     return 0
@@ -30,7 +30,7 @@
 
     __slots__ = ['_Rat__num', '_Rat__den']
 
-    def __init__(self, num=0L, den=1L):
+    def __init__(self, num=0, den=1):
         """Constructor: Rat([num[, den]]).
 
         The arguments must be ints or longs, and default to (0, 1)."""
@@ -42,8 +42,8 @@
         if den == 0:
             raise ZeroDivisionError, "zero denominator"
         g = gcd(den, num)
-        self.__num = long(num//g)
-        self.__den = long(den//g)
+        self.__num = int(num//g)
+        self.__den = int(den//g)
 
     def _get_num(self):
         """Accessor function for read-only 'num' attribute of Rat."""
@@ -80,7 +80,7 @@
     def __long__(self):
         """Convert a Rat to an long; self.den must be 1."""
         if self.__den == 1:
-            return long(self.__num)
+            return int(self.__num)
         raise ValueError, "can't convert %s to long" % repr(self)
 
     def __add__(self, other):
@@ -225,7 +225,7 @@
         a = Rat(10, 15)
         self.assertEqual(a.num, 2)
         self.assertEqual(a.den, 3)
-        a = Rat(10L, 15L)
+        a = Rat(10, 15)
         self.assertEqual(a.num, 2)
         self.assertEqual(a.den, 3)
         a = Rat(10, -15)
diff --git a/Lib/test/test_builtin.py b/Lib/test/test_builtin.py
index fb859d4..56417a3 100644
--- a/Lib/test/test_builtin.py
+++ b/Lib/test/test_builtin.py
@@ -122,9 +122,9 @@
         self.assertEqual(abs(3.14), 3.14)
         self.assertEqual(abs(-3.14), 3.14)
         # long
-        self.assertEqual(abs(0L), 0L)
-        self.assertEqual(abs(1234L), 1234L)
-        self.assertEqual(abs(-1234L), 1234L)
+        self.assertEqual(abs(0), 0)
+        self.assertEqual(abs(1234), 1234)
+        self.assertEqual(abs(-1234), 1234)
         # str
         self.assertRaises(TypeError, abs, 'a')
 
@@ -235,15 +235,15 @@
         self.assertEqual(divmod(12, -7), (-2, -2))
         self.assertEqual(divmod(-12, -7), (1, -5))
 
-        self.assertEqual(divmod(12L, 7L), (1L, 5L))
-        self.assertEqual(divmod(-12L, 7L), (-2L, 2L))
-        self.assertEqual(divmod(12L, -7L), (-2L, -2L))
-        self.assertEqual(divmod(-12L, -7L), (1L, -5L))
+        self.assertEqual(divmod(12, 7), (1, 5))
+        self.assertEqual(divmod(-12, 7), (-2, 2))
+        self.assertEqual(divmod(12, -7), (-2, -2))
+        self.assertEqual(divmod(-12, -7), (1, -5))
 
-        self.assertEqual(divmod(12, 7L), (1, 5L))
-        self.assertEqual(divmod(-12, 7L), (-2, 2L))
-        self.assertEqual(divmod(12L, -7), (-2L, -2))
-        self.assertEqual(divmod(-12L, -7), (1L, -5))
+        self.assertEqual(divmod(12, 7), (1, 5))
+        self.assertEqual(divmod(-12, 7), (-2, 2))
+        self.assertEqual(divmod(12, -7), (-2, -2))
+        self.assertEqual(divmod(-12, -7), (1, -5))
 
         self.assertEqual(divmod(-sys.maxint-1, -1),
                          (sys.maxint+1, 0))
@@ -538,7 +538,7 @@
     def test_float(self):
         self.assertEqual(float(3.14), 3.14)
         self.assertEqual(float(314), 314.0)
-        self.assertEqual(float(314L), 314.0)
+        self.assertEqual(float(314), 314.0)
         self.assertEqual(float("  3.14  "), 3.14)
         self.assertRaises(ValueError, float, "  0x3.1  ")
         self.assertRaises(ValueError, float, "  -0x3.p-1  ")
@@ -624,7 +624,7 @@
 
     def test_hash(self):
         hash(None)
-        self.assertEqual(hash(1), hash(1L))
+        self.assertEqual(hash(1), hash(1))
         self.assertEqual(hash(1), hash(1.0))
         hash('spam')
         if have_unicode:
@@ -642,22 +642,22 @@
             def __hash__(self):
                 return 2**100
         self.assertEquals(type(hash(Y())), int)
-        class Z(long):
+        class Z(int):
             def __hash__(self):
                 return self
-        self.assertEquals(hash(Z(42)), hash(42L))
+        self.assertEquals(hash(Z(42)), hash(42))
 
     def test_hex(self):
         self.assertEqual(hex(16), '0x10')
-        self.assertEqual(hex(16L), '0x10')
+        self.assertEqual(hex(16), '0x10')
         self.assertEqual(hex(-16), '-0x10')
-        self.assertEqual(hex(-16L), '-0x10')
+        self.assertEqual(hex(-16), '-0x10')
         self.assertRaises(TypeError, hex, {})
 
     def test_id(self):
         id(None)
         id(1)
-        id(1L)
+        id(1)
         id(1.0)
         id('spam')
         id((0,1,2,3))
@@ -667,7 +667,7 @@
     def test_int(self):
         self.assertEqual(int(314), 314)
         self.assertEqual(int(3.14), 3)
-        self.assertEqual(int(314L), 314)
+        self.assertEqual(int(314), 314)
         # Check that conversion from float truncates towards zero
         self.assertEqual(int(-3.14), -3)
         self.assertEqual(int(3.9), 3)
@@ -675,9 +675,9 @@
         self.assertEqual(int(3.5), 3)
         self.assertEqual(int(-3.5), -3)
         # Different base:
-        self.assertEqual(int("10",16), 16L)
+        self.assertEqual(int("10",16), 16)
         if have_unicode:
-            self.assertEqual(int(unicode("10"),16), 16L)
+            self.assertEqual(int(unicode("10"),16), 16)
         # Test conversion from strings and various anomalies
         for s, v in L:
             for sign in "", "+", "-":
@@ -700,9 +700,9 @@
 
         # should return long
         x = int(1e100)
-        self.assert_(isinstance(x, long))
+        self.assert_(isinstance(x, int))
         x = int(-1e100)
-        self.assert_(isinstance(x, long))
+        self.assert_(isinstance(x, int))
 
 
         # SF bug 434186:  0x80000000/2 != 0x80000000>>1.
@@ -720,11 +720,11 @@
         self.assertRaises(ValueError, int, '123\x00 245', 20)
 
         x = int('1' * 600)
-        self.assert_(isinstance(x, long))
+        self.assert_(isinstance(x, int))
 
         if have_unicode:
             x = int(unichr(0x661) * 600)
-            self.assert_(isinstance(x, long))
+            self.assert_(isinstance(x, int))
 
         self.assertRaises(TypeError, int, 1, 12)
 
@@ -735,79 +735,79 @@
         # Various representations of 2**32 evaluated to 0
         # rather than 2**32 in previous versions
 
-        self.assertEqual(int('100000000000000000000000000000000', 2), 4294967296L)
-        self.assertEqual(int('102002022201221111211', 3), 4294967296L)
-        self.assertEqual(int('10000000000000000', 4), 4294967296L)
-        self.assertEqual(int('32244002423141', 5), 4294967296L)
-        self.assertEqual(int('1550104015504', 6), 4294967296L)
-        self.assertEqual(int('211301422354', 7), 4294967296L)
-        self.assertEqual(int('40000000000', 8), 4294967296L)
-        self.assertEqual(int('12068657454', 9), 4294967296L)
-        self.assertEqual(int('4294967296', 10), 4294967296L)
-        self.assertEqual(int('1904440554', 11), 4294967296L)
-        self.assertEqual(int('9ba461594', 12), 4294967296L)
-        self.assertEqual(int('535a79889', 13), 4294967296L)
-        self.assertEqual(int('2ca5b7464', 14), 4294967296L)
-        self.assertEqual(int('1a20dcd81', 15), 4294967296L)
-        self.assertEqual(int('100000000', 16), 4294967296L)
-        self.assertEqual(int('a7ffda91', 17), 4294967296L)
-        self.assertEqual(int('704he7g4', 18), 4294967296L)
-        self.assertEqual(int('4f5aff66', 19), 4294967296L)
-        self.assertEqual(int('3723ai4g', 20), 4294967296L)
-        self.assertEqual(int('281d55i4', 21), 4294967296L)
-        self.assertEqual(int('1fj8b184', 22), 4294967296L)
-        self.assertEqual(int('1606k7ic', 23), 4294967296L)
-        self.assertEqual(int('mb994ag', 24), 4294967296L)
-        self.assertEqual(int('hek2mgl', 25), 4294967296L)
-        self.assertEqual(int('dnchbnm', 26), 4294967296L)
-        self.assertEqual(int('b28jpdm', 27), 4294967296L)
-        self.assertEqual(int('8pfgih4', 28), 4294967296L)
-        self.assertEqual(int('76beigg', 29), 4294967296L)
-        self.assertEqual(int('5qmcpqg', 30), 4294967296L)
-        self.assertEqual(int('4q0jto4', 31), 4294967296L)
-        self.assertEqual(int('4000000', 32), 4294967296L)
-        self.assertEqual(int('3aokq94', 33), 4294967296L)
-        self.assertEqual(int('2qhxjli', 34), 4294967296L)
-        self.assertEqual(int('2br45qb', 35), 4294967296L)
-        self.assertEqual(int('1z141z4', 36), 4294967296L)
+        self.assertEqual(int('100000000000000000000000000000000', 2), 4294967296)
+        self.assertEqual(int('102002022201221111211', 3), 4294967296)
+        self.assertEqual(int('10000000000000000', 4), 4294967296)
+        self.assertEqual(int('32244002423141', 5), 4294967296)
+        self.assertEqual(int('1550104015504', 6), 4294967296)
+        self.assertEqual(int('211301422354', 7), 4294967296)
+        self.assertEqual(int('40000000000', 8), 4294967296)
+        self.assertEqual(int('12068657454', 9), 4294967296)
+        self.assertEqual(int('4294967296', 10), 4294967296)
+        self.assertEqual(int('1904440554', 11), 4294967296)
+        self.assertEqual(int('9ba461594', 12), 4294967296)
+        self.assertEqual(int('535a79889', 13), 4294967296)
+        self.assertEqual(int('2ca5b7464', 14), 4294967296)
+        self.assertEqual(int('1a20dcd81', 15), 4294967296)
+        self.assertEqual(int('100000000', 16), 4294967296)
+        self.assertEqual(int('a7ffda91', 17), 4294967296)
+        self.assertEqual(int('704he7g4', 18), 4294967296)
+        self.assertEqual(int('4f5aff66', 19), 4294967296)
+        self.assertEqual(int('3723ai4g', 20), 4294967296)
+        self.assertEqual(int('281d55i4', 21), 4294967296)
+        self.assertEqual(int('1fj8b184', 22), 4294967296)
+        self.assertEqual(int('1606k7ic', 23), 4294967296)
+        self.assertEqual(int('mb994ag', 24), 4294967296)
+        self.assertEqual(int('hek2mgl', 25), 4294967296)
+        self.assertEqual(int('dnchbnm', 26), 4294967296)
+        self.assertEqual(int('b28jpdm', 27), 4294967296)
+        self.assertEqual(int('8pfgih4', 28), 4294967296)
+        self.assertEqual(int('76beigg', 29), 4294967296)
+        self.assertEqual(int('5qmcpqg', 30), 4294967296)
+        self.assertEqual(int('4q0jto4', 31), 4294967296)
+        self.assertEqual(int('4000000', 32), 4294967296)
+        self.assertEqual(int('3aokq94', 33), 4294967296)
+        self.assertEqual(int('2qhxjli', 34), 4294967296)
+        self.assertEqual(int('2br45qb', 35), 4294967296)
+        self.assertEqual(int('1z141z4', 36), 4294967296)
 
         # SF bug 1334662: int(string, base) wrong answers
         # Checks for proper evaluation of 2**32 + 1
-        self.assertEqual(int('100000000000000000000000000000001', 2), 4294967297L)
-        self.assertEqual(int('102002022201221111212', 3), 4294967297L)
-        self.assertEqual(int('10000000000000001', 4), 4294967297L)
-        self.assertEqual(int('32244002423142', 5), 4294967297L)
-        self.assertEqual(int('1550104015505', 6), 4294967297L)
-        self.assertEqual(int('211301422355', 7), 4294967297L)
-        self.assertEqual(int('40000000001', 8), 4294967297L)
-        self.assertEqual(int('12068657455', 9), 4294967297L)
-        self.assertEqual(int('4294967297', 10), 4294967297L)
-        self.assertEqual(int('1904440555', 11), 4294967297L)
-        self.assertEqual(int('9ba461595', 12), 4294967297L)
-        self.assertEqual(int('535a7988a', 13), 4294967297L)
-        self.assertEqual(int('2ca5b7465', 14), 4294967297L)
-        self.assertEqual(int('1a20dcd82', 15), 4294967297L)
-        self.assertEqual(int('100000001', 16), 4294967297L)
-        self.assertEqual(int('a7ffda92', 17), 4294967297L)
-        self.assertEqual(int('704he7g5', 18), 4294967297L)
-        self.assertEqual(int('4f5aff67', 19), 4294967297L)
-        self.assertEqual(int('3723ai4h', 20), 4294967297L)
-        self.assertEqual(int('281d55i5', 21), 4294967297L)
-        self.assertEqual(int('1fj8b185', 22), 4294967297L)
-        self.assertEqual(int('1606k7id', 23), 4294967297L)
-        self.assertEqual(int('mb994ah', 24), 4294967297L)
-        self.assertEqual(int('hek2mgm', 25), 4294967297L)
-        self.assertEqual(int('dnchbnn', 26), 4294967297L)
-        self.assertEqual(int('b28jpdn', 27), 4294967297L)
-        self.assertEqual(int('8pfgih5', 28), 4294967297L)
-        self.assertEqual(int('76beigh', 29), 4294967297L)
-        self.assertEqual(int('5qmcpqh', 30), 4294967297L)
-        self.assertEqual(int('4q0jto5', 31), 4294967297L)
-        self.assertEqual(int('4000001', 32), 4294967297L)
-        self.assertEqual(int('3aokq95', 33), 4294967297L)
-        self.assertEqual(int('2qhxjlj', 34), 4294967297L)
-        self.assertEqual(int('2br45qc', 35), 4294967297L)
-        self.assertEqual(int('1z141z5', 36), 4294967297L)
+        self.assertEqual(int('100000000000000000000000000000001', 2), 4294967297)
+        self.assertEqual(int('102002022201221111212', 3), 4294967297)
+        self.assertEqual(int('10000000000000001', 4), 4294967297)
+        self.assertEqual(int('32244002423142', 5), 4294967297)
+        self.assertEqual(int('1550104015505', 6), 4294967297)
+        self.assertEqual(int('211301422355', 7), 4294967297)
+        self.assertEqual(int('40000000001', 8), 4294967297)
+        self.assertEqual(int('12068657455', 9), 4294967297)
+        self.assertEqual(int('4294967297', 10), 4294967297)
+        self.assertEqual(int('1904440555', 11), 4294967297)
+        self.assertEqual(int('9ba461595', 12), 4294967297)
+        self.assertEqual(int('535a7988a', 13), 4294967297)
+        self.assertEqual(int('2ca5b7465', 14), 4294967297)
+        self.assertEqual(int('1a20dcd82', 15), 4294967297)
+        self.assertEqual(int('100000001', 16), 4294967297)
+        self.assertEqual(int('a7ffda92', 17), 4294967297)
+        self.assertEqual(int('704he7g5', 18), 4294967297)
+        self.assertEqual(int('4f5aff67', 19), 4294967297)
+        self.assertEqual(int('3723ai4h', 20), 4294967297)
+        self.assertEqual(int('281d55i5', 21), 4294967297)
+        self.assertEqual(int('1fj8b185', 22), 4294967297)
+        self.assertEqual(int('1606k7id', 23), 4294967297)
+        self.assertEqual(int('mb994ah', 24), 4294967297)
+        self.assertEqual(int('hek2mgm', 25), 4294967297)
+        self.assertEqual(int('dnchbnn', 26), 4294967297)
+        self.assertEqual(int('b28jpdn', 27), 4294967297)
+        self.assertEqual(int('8pfgih5', 28), 4294967297)
+        self.assertEqual(int('76beigh', 29), 4294967297)
+        self.assertEqual(int('5qmcpqh', 30), 4294967297)
+        self.assertEqual(int('4q0jto5', 31), 4294967297)
+        self.assertEqual(int('4000001', 32), 4294967297)
+        self.assertEqual(int('3aokq95', 33), 4294967297)
+        self.assertEqual(int('2qhxjlj', 34), 4294967297)
+        self.assertEqual(int('2br45qc', 35), 4294967297)
+        self.assertEqual(int('1z141z5', 36), 4294967297)
 
     def test_intconversion(self):
         # Test __int__()
@@ -829,7 +829,7 @@
 
         class Foo4(int):
             def __int__(self):
-                return 42L
+                return 42
 
         class Foo5(int):
             def __int__(self):
@@ -839,7 +839,7 @@
         self.assertEqual(int(Foo1()), 42)
         self.assertEqual(int(Foo2()), 42)
         self.assertEqual(int(Foo3()), 0)
-        self.assertEqual(int(Foo4()), 42L)
+        self.assertEqual(int(Foo4()), 42)
         self.assertRaises(TypeError, int, Foo5())
 
     def test_iter(self):
@@ -935,32 +935,32 @@
         self.assertEqual(x, [])
 
     def test_long(self):
-        self.assertEqual(long(314), 314L)
-        self.assertEqual(long(3.14), 3L)
-        self.assertEqual(long(314L), 314L)
+        self.assertEqual(int(314), 314)
+        self.assertEqual(int(3.14), 3)
+        self.assertEqual(int(314), 314)
         # Check that conversion from float truncates towards zero
-        self.assertEqual(long(-3.14), -3L)
-        self.assertEqual(long(3.9), 3L)
-        self.assertEqual(long(-3.9), -3L)
-        self.assertEqual(long(3.5), 3L)
-        self.assertEqual(long(-3.5), -3L)
-        self.assertEqual(long("-3"), -3L)
+        self.assertEqual(int(-3.14), -3)
+        self.assertEqual(int(3.9), 3)
+        self.assertEqual(int(-3.9), -3)
+        self.assertEqual(int(3.5), 3)
+        self.assertEqual(int(-3.5), -3)
+        self.assertEqual(int("-3"), -3)
         if have_unicode:
-            self.assertEqual(long(unicode("-3")), -3L)
+            self.assertEqual(int(unicode("-3")), -3)
         # Different base:
-        self.assertEqual(long("10",16), 16L)
+        self.assertEqual(int("10",16), 16)
         if have_unicode:
-            self.assertEqual(long(unicode("10"),16), 16L)
+            self.assertEqual(int(unicode("10"),16), 16)
         # Check conversions from string (same test set as for int(), and then some)
         LL = [
-                ('1' + '0'*20, 10L**20),
-                ('1' + '0'*100, 10L**100)
+                ('1' + '0'*20, 10**20),
+                ('1' + '0'*100, 10**100)
         ]
         L2 = L[:]
         if have_unicode:
             L2 += [
-                (unicode('1') + unicode('0')*20, 10L**20),
-                (unicode('1') + unicode('0')*100, 10L**100),
+                (unicode('1') + unicode('0')*20, 10**20),
+                (unicode('1') + unicode('0')*100, 10**100),
         ]
         for s, v in L2 + LL:
             for sign in "", "+", "-":
@@ -970,120 +970,120 @@
                     if sign == "-" and v is not ValueError:
                         vv = -v
                     try:
-                        self.assertEqual(long(ss), long(vv))
+                        self.assertEqual(int(ss), int(vv))
                     except v:
                         pass
 
-        self.assertRaises(ValueError, long, '123\0')
-        self.assertRaises(ValueError, long, '53', 40)
-        self.assertRaises(TypeError, long, 1, 12)
+        self.assertRaises(ValueError, int, '123\0')
+        self.assertRaises(ValueError, int, '53', 40)
+        self.assertRaises(TypeError, int, 1, 12)
 
-        self.assertEqual(long('100000000000000000000000000000000', 2),
+        self.assertEqual(int('100000000000000000000000000000000', 2),
                          4294967296)
-        self.assertEqual(long('102002022201221111211', 3), 4294967296)
-        self.assertEqual(long('10000000000000000', 4), 4294967296)
-        self.assertEqual(long('32244002423141', 5), 4294967296)
-        self.assertEqual(long('1550104015504', 6), 4294967296)
-        self.assertEqual(long('211301422354', 7), 4294967296)
-        self.assertEqual(long('40000000000', 8), 4294967296)
-        self.assertEqual(long('12068657454', 9), 4294967296)
-        self.assertEqual(long('4294967296', 10), 4294967296)
-        self.assertEqual(long('1904440554', 11), 4294967296)
-        self.assertEqual(long('9ba461594', 12), 4294967296)
-        self.assertEqual(long('535a79889', 13), 4294967296)
-        self.assertEqual(long('2ca5b7464', 14), 4294967296)
-        self.assertEqual(long('1a20dcd81', 15), 4294967296)
-        self.assertEqual(long('100000000', 16), 4294967296)
-        self.assertEqual(long('a7ffda91', 17), 4294967296)
-        self.assertEqual(long('704he7g4', 18), 4294967296)
-        self.assertEqual(long('4f5aff66', 19), 4294967296)
-        self.assertEqual(long('3723ai4g', 20), 4294967296)
-        self.assertEqual(long('281d55i4', 21), 4294967296)
-        self.assertEqual(long('1fj8b184', 22), 4294967296)
-        self.assertEqual(long('1606k7ic', 23), 4294967296)
-        self.assertEqual(long('mb994ag', 24), 4294967296)
-        self.assertEqual(long('hek2mgl', 25), 4294967296)
-        self.assertEqual(long('dnchbnm', 26), 4294967296)
-        self.assertEqual(long('b28jpdm', 27), 4294967296)
-        self.assertEqual(long('8pfgih4', 28), 4294967296)
-        self.assertEqual(long('76beigg', 29), 4294967296)
-        self.assertEqual(long('5qmcpqg', 30), 4294967296)
-        self.assertEqual(long('4q0jto4', 31), 4294967296)
-        self.assertEqual(long('4000000', 32), 4294967296)
-        self.assertEqual(long('3aokq94', 33), 4294967296)
-        self.assertEqual(long('2qhxjli', 34), 4294967296)
-        self.assertEqual(long('2br45qb', 35), 4294967296)
-        self.assertEqual(long('1z141z4', 36), 4294967296)
+        self.assertEqual(int('102002022201221111211', 3), 4294967296)
+        self.assertEqual(int('10000000000000000', 4), 4294967296)
+        self.assertEqual(int('32244002423141', 5), 4294967296)
+        self.assertEqual(int('1550104015504', 6), 4294967296)
+        self.assertEqual(int('211301422354', 7), 4294967296)
+        self.assertEqual(int('40000000000', 8), 4294967296)
+        self.assertEqual(int('12068657454', 9), 4294967296)
+        self.assertEqual(int('4294967296', 10), 4294967296)
+        self.assertEqual(int('1904440554', 11), 4294967296)
+        self.assertEqual(int('9ba461594', 12), 4294967296)
+        self.assertEqual(int('535a79889', 13), 4294967296)
+        self.assertEqual(int('2ca5b7464', 14), 4294967296)
+        self.assertEqual(int('1a20dcd81', 15), 4294967296)
+        self.assertEqual(int('100000000', 16), 4294967296)
+        self.assertEqual(int('a7ffda91', 17), 4294967296)
+        self.assertEqual(int('704he7g4', 18), 4294967296)
+        self.assertEqual(int('4f5aff66', 19), 4294967296)
+        self.assertEqual(int('3723ai4g', 20), 4294967296)
+        self.assertEqual(int('281d55i4', 21), 4294967296)
+        self.assertEqual(int('1fj8b184', 22), 4294967296)
+        self.assertEqual(int('1606k7ic', 23), 4294967296)
+        self.assertEqual(int('mb994ag', 24), 4294967296)
+        self.assertEqual(int('hek2mgl', 25), 4294967296)
+        self.assertEqual(int('dnchbnm', 26), 4294967296)
+        self.assertEqual(int('b28jpdm', 27), 4294967296)
+        self.assertEqual(int('8pfgih4', 28), 4294967296)
+        self.assertEqual(int('76beigg', 29), 4294967296)
+        self.assertEqual(int('5qmcpqg', 30), 4294967296)
+        self.assertEqual(int('4q0jto4', 31), 4294967296)
+        self.assertEqual(int('4000000', 32), 4294967296)
+        self.assertEqual(int('3aokq94', 33), 4294967296)
+        self.assertEqual(int('2qhxjli', 34), 4294967296)
+        self.assertEqual(int('2br45qb', 35), 4294967296)
+        self.assertEqual(int('1z141z4', 36), 4294967296)
 
-        self.assertEqual(long('100000000000000000000000000000001', 2),
+        self.assertEqual(int('100000000000000000000000000000001', 2),
                          4294967297)
-        self.assertEqual(long('102002022201221111212', 3), 4294967297)
-        self.assertEqual(long('10000000000000001', 4), 4294967297)
-        self.assertEqual(long('32244002423142', 5), 4294967297)
-        self.assertEqual(long('1550104015505', 6), 4294967297)
-        self.assertEqual(long('211301422355', 7), 4294967297)
-        self.assertEqual(long('40000000001', 8), 4294967297)
-        self.assertEqual(long('12068657455', 9), 4294967297)
-        self.assertEqual(long('4294967297', 10), 4294967297)
-        self.assertEqual(long('1904440555', 11), 4294967297)
-        self.assertEqual(long('9ba461595', 12), 4294967297)
-        self.assertEqual(long('535a7988a', 13), 4294967297)
-        self.assertEqual(long('2ca5b7465', 14), 4294967297)
-        self.assertEqual(long('1a20dcd82', 15), 4294967297)
-        self.assertEqual(long('100000001', 16), 4294967297)
-        self.assertEqual(long('a7ffda92', 17), 4294967297)
-        self.assertEqual(long('704he7g5', 18), 4294967297)
-        self.assertEqual(long('4f5aff67', 19), 4294967297)
-        self.assertEqual(long('3723ai4h', 20), 4294967297)
-        self.assertEqual(long('281d55i5', 21), 4294967297)
-        self.assertEqual(long('1fj8b185', 22), 4294967297)
-        self.assertEqual(long('1606k7id', 23), 4294967297)
-        self.assertEqual(long('mb994ah', 24), 4294967297)
-        self.assertEqual(long('hek2mgm', 25), 4294967297)
-        self.assertEqual(long('dnchbnn', 26), 4294967297)
-        self.assertEqual(long('b28jpdn', 27), 4294967297)
-        self.assertEqual(long('8pfgih5', 28), 4294967297)
-        self.assertEqual(long('76beigh', 29), 4294967297)
-        self.assertEqual(long('5qmcpqh', 30), 4294967297)
-        self.assertEqual(long('4q0jto5', 31), 4294967297)
-        self.assertEqual(long('4000001', 32), 4294967297)
-        self.assertEqual(long('3aokq95', 33), 4294967297)
-        self.assertEqual(long('2qhxjlj', 34), 4294967297)
-        self.assertEqual(long('2br45qc', 35), 4294967297)
-        self.assertEqual(long('1z141z5', 36), 4294967297)
+        self.assertEqual(int('102002022201221111212', 3), 4294967297)
+        self.assertEqual(int('10000000000000001', 4), 4294967297)
+        self.assertEqual(int('32244002423142', 5), 4294967297)
+        self.assertEqual(int('1550104015505', 6), 4294967297)
+        self.assertEqual(int('211301422355', 7), 4294967297)
+        self.assertEqual(int('40000000001', 8), 4294967297)
+        self.assertEqual(int('12068657455', 9), 4294967297)
+        self.assertEqual(int('4294967297', 10), 4294967297)
+        self.assertEqual(int('1904440555', 11), 4294967297)
+        self.assertEqual(int('9ba461595', 12), 4294967297)
+        self.assertEqual(int('535a7988a', 13), 4294967297)
+        self.assertEqual(int('2ca5b7465', 14), 4294967297)
+        self.assertEqual(int('1a20dcd82', 15), 4294967297)
+        self.assertEqual(int('100000001', 16), 4294967297)
+        self.assertEqual(int('a7ffda92', 17), 4294967297)
+        self.assertEqual(int('704he7g5', 18), 4294967297)
+        self.assertEqual(int('4f5aff67', 19), 4294967297)
+        self.assertEqual(int('3723ai4h', 20), 4294967297)
+        self.assertEqual(int('281d55i5', 21), 4294967297)
+        self.assertEqual(int('1fj8b185', 22), 4294967297)
+        self.assertEqual(int('1606k7id', 23), 4294967297)
+        self.assertEqual(int('mb994ah', 24), 4294967297)
+        self.assertEqual(int('hek2mgm', 25), 4294967297)
+        self.assertEqual(int('dnchbnn', 26), 4294967297)
+        self.assertEqual(int('b28jpdn', 27), 4294967297)
+        self.assertEqual(int('8pfgih5', 28), 4294967297)
+        self.assertEqual(int('76beigh', 29), 4294967297)
+        self.assertEqual(int('5qmcpqh', 30), 4294967297)
+        self.assertEqual(int('4q0jto5', 31), 4294967297)
+        self.assertEqual(int('4000001', 32), 4294967297)
+        self.assertEqual(int('3aokq95', 33), 4294967297)
+        self.assertEqual(int('2qhxjlj', 34), 4294967297)
+        self.assertEqual(int('2br45qc', 35), 4294967297)
+        self.assertEqual(int('1z141z5', 36), 4294967297)
 
 
     def test_longconversion(self):
         # Test __long__()
         class Foo0:
             def __long__(self):
-                return 42L
+                return 42
 
         class Foo1(object):
             def __long__(self):
-                return 42L
+                return 42
 
-        class Foo2(long):
-            def __long__(self):
-                return 42L
-
-        class Foo3(long):
-            def __long__(self):
-                return self
-
-        class Foo4(long):
+        class Foo2(int):
             def __long__(self):
                 return 42
 
-        class Foo5(long):
+        class Foo3(int):
+            def __long__(self):
+                return self
+
+        class Foo4(int):
+            def __long__(self):
+                return 42
+
+        class Foo5(int):
             def __long__(self):
                 return 42.
 
-        self.assertEqual(long(Foo0()), 42L)
-        self.assertEqual(long(Foo1()), 42L)
+        self.assertEqual(int(Foo0()), 42)
+        self.assertEqual(int(Foo1()), 42)
 	# XXX invokes __int__ now
         # self.assertEqual(long(Foo2()), 42L)
-        self.assertEqual(long(Foo3()), 0)
+        self.assertEqual(int(Foo3()), 0)
 	# XXX likewise
         # self.assertEqual(long(Foo4()), 42)
         # self.assertRaises(TypeError, long, Foo5())
@@ -1174,9 +1174,9 @@
         self.assertEqual(max((1, 2, 3, 1, 2, 3)), 3)
         self.assertEqual(max([1, 2, 3, 1, 2, 3]), 3)
 
-        self.assertEqual(max(1, 2L, 3.0), 3.0)
-        self.assertEqual(max(1L, 2.0, 3), 3)
-        self.assertEqual(max(1.0, 2, 3L), 3L)
+        self.assertEqual(max(1, 2, 3.0), 3.0)
+        self.assertEqual(max(1, 2.0, 3), 3)
+        self.assertEqual(max(1.0, 2, 3), 3)
 
         for stmt in (
             "max(key=int)",                 # no args
@@ -1208,9 +1208,9 @@
         self.assertEqual(min((1, 2, 3, 1, 2, 3)), 1)
         self.assertEqual(min([1, 2, 3, 1, 2, 3]), 1)
 
-        self.assertEqual(min(1, 2L, 3.0), 1)
-        self.assertEqual(min(1L, 2.0, 3), 1L)
-        self.assertEqual(min(1.0, 2, 3L), 1.0)
+        self.assertEqual(min(1, 2, 3.0), 1)
+        self.assertEqual(min(1, 2.0, 3), 1)
+        self.assertEqual(min(1.0, 2, 3), 1.0)
 
         self.assertRaises(TypeError, min)
         self.assertRaises(TypeError, min, 42)
@@ -1250,9 +1250,9 @@
 
     def test_oct(self):
         self.assertEqual(oct(100), '0144')
-        self.assertEqual(oct(100L), '0144')
+        self.assertEqual(oct(100), '0144')
         self.assertEqual(oct(-100), '-0144')
-        self.assertEqual(oct(-100L), '-0144')
+        self.assertEqual(oct(-100), '-0144')
         self.assertRaises(TypeError, oct, ())
 
     def write_testfile(self):
@@ -1309,20 +1309,20 @@
         self.assertEqual(pow(-2,2), 4)
         self.assertEqual(pow(-2,3), -8)
 
-        self.assertEqual(pow(0L,0), 1)
-        self.assertEqual(pow(0L,1), 0)
-        self.assertEqual(pow(1L,0), 1)
-        self.assertEqual(pow(1L,1), 1)
+        self.assertEqual(pow(0,0), 1)
+        self.assertEqual(pow(0,1), 0)
+        self.assertEqual(pow(1,0), 1)
+        self.assertEqual(pow(1,1), 1)
 
-        self.assertEqual(pow(2L,0), 1)
-        self.assertEqual(pow(2L,10), 1024)
-        self.assertEqual(pow(2L,20), 1024*1024)
-        self.assertEqual(pow(2L,30), 1024*1024*1024)
+        self.assertEqual(pow(2,0), 1)
+        self.assertEqual(pow(2,10), 1024)
+        self.assertEqual(pow(2,20), 1024*1024)
+        self.assertEqual(pow(2,30), 1024*1024*1024)
 
-        self.assertEqual(pow(-2L,0), 1)
-        self.assertEqual(pow(-2L,1), -2)
-        self.assertEqual(pow(-2L,2), 4)
-        self.assertEqual(pow(-2L,3), -8)
+        self.assertEqual(pow(-2,0), 1)
+        self.assertEqual(pow(-2,1), -2)
+        self.assertEqual(pow(-2,2), 4)
+        self.assertEqual(pow(-2,3), -8)
 
         self.assertAlmostEqual(pow(0.,0), 1.)
         self.assertAlmostEqual(pow(0.,1), 0.)
@@ -1339,9 +1339,9 @@
         self.assertAlmostEqual(pow(-2.,2), 4.)
         self.assertAlmostEqual(pow(-2.,3), -8.)
 
-        for x in 2, 2L, 2.0:
-            for y in 10, 10L, 10.0:
-                for z in 1000, 1000L, 1000.0:
+        for x in 2, 2, 2.0:
+            for y in 10, 10, 10.0:
+                for z in 1000, 1000, 1000.0:
                     if isinstance(x, float) or \
                        isinstance(y, float) or \
                        isinstance(z, float):
@@ -1351,8 +1351,8 @@
 
         self.assertRaises(TypeError, pow, -1, -2, 3)
         self.assertRaises(ValueError, pow, 1, 2, 0)
-        self.assertRaises(TypeError, pow, -1L, -2L, 3L)
-        self.assertRaises(ValueError, pow, 1L, 2L, 0L)
+        self.assertRaises(TypeError, pow, -1, -2, 3)
+        self.assertRaises(ValueError, pow, 1, 2, 0)
         self.assertRaises(ValueError, pow, -342.43, 0.234)
 
         self.assertRaises(TypeError, pow)
@@ -1371,12 +1371,12 @@
         self.assertEqual(range(0, 2**100, -1), [])
         self.assertEqual(range(0, 2**100, -1), [])
 
-        a = long(10 * sys.maxint)
-        b = long(100 * sys.maxint)
-        c = long(50 * sys.maxint)
+        a = int(10 * sys.maxint)
+        b = int(100 * sys.maxint)
+        c = int(50 * sys.maxint)
 
         self.assertEqual(range(a, a+2), [a, a+1])
-        self.assertEqual(range(a+2, a, -1L), [a+2, a+1])
+        self.assertEqual(range(a+2, a, -1), [a+2, a+1])
         self.assertEqual(range(a+4, a, -2), [a+4, a+2])
 
         seq = range(a, b, c)
@@ -1397,7 +1397,7 @@
         self.assertRaises(TypeError, range)
         self.assertRaises(TypeError, range, 1, 2, 3, 4)
         self.assertRaises(ValueError, range, 1, 2, 0)
-        self.assertRaises(ValueError, range, a, a + 1, long(0))
+        self.assertRaises(ValueError, range, a, a + 1, int(0))
 
         class badzero(int):
             def __eq__(self, other):
@@ -1428,7 +1428,7 @@
     def test_repr(self):
         self.assertEqual(repr(''), '\'\'')
         self.assertEqual(repr(0), '0')
-        self.assertEqual(repr(0L), '0')
+        self.assertEqual(repr(0), '0')
         self.assertEqual(repr(()), '()')
         self.assertEqual(repr([]), '[]')
         self.assertEqual(repr({}), '{}')
@@ -1484,7 +1484,7 @@
     def test_str(self):
         self.assertEqual(str(''), '')
         self.assertEqual(str(0), '0')
-        self.assertEqual(str(0L), '0')
+        self.assertEqual(str(0), '0')
         self.assertEqual(str(()), '()')
         self.assertEqual(str([]), '[]')
         self.assertEqual(str({}), '{}')
diff --git a/Lib/test/test_bytes.py b/Lib/test/test_bytes.py
index be95935..997122b 100644
--- a/Lib/test/test_bytes.py
+++ b/Lib/test/test_bytes.py
@@ -361,9 +361,9 @@
     def test_contains(self):
         b = bytes("abc")
         self.failUnless(ord('a') in b)
-        self.failUnless(long(ord('a')) in b)
+        self.failUnless(int(ord('a')) in b)
         self.failIf(200 in b)
-        self.failIf(200L in b)
+        self.failIf(200 in b)
         self.assertRaises(ValueError, lambda: 300 in b)
         self.assertRaises(ValueError, lambda: -1 in b)
         self.assertRaises(TypeError, lambda: None in b)
diff --git a/Lib/test/test_class.py b/Lib/test/test_class.py
index 1758fd4..c450c80 100644
--- a/Lib/test/test_class.py
+++ b/Lib/test/test_class.py
@@ -84,10 +84,6 @@
         print "__float__:", args
         return 1.0
 
-    def __long__(self, *args):
-        print "__long__:", args
-        return 1L
-
     def __oct__(self, *args):
         print "__oct__:", args
         return '01'
@@ -238,7 +234,7 @@
 +testme
 abs(testme)
 int(testme)
-long(testme)
+int(testme)
 float(testme)
 oct(testme)
 hex(testme)
@@ -289,7 +285,6 @@
     def __int__(self):
         return None
     __float__ = __int__
-    __long__ = __int__
     __str__ = __int__
     __repr__ = __int__
     __oct__ = __int__
@@ -307,31 +302,11 @@
 
 check_exc("int(BadTypeClass())", TypeError)
 check_exc("float(BadTypeClass())", TypeError)
-check_exc("long(BadTypeClass())", TypeError)
 check_exc("str(BadTypeClass())", TypeError)
 check_exc("repr(BadTypeClass())", TypeError)
 check_exc("oct(BadTypeClass())", TypeError)
 check_exc("hex(BadTypeClass())", TypeError)
 
-# mixing up ints and longs is okay
-class IntLongMixClass:
-    def __int__(self):
-        return 0L
-
-    def __long__(self):
-        return 0
-
-try:
-    int(IntLongMixClass())
-except TypeError:
-    raise TestFailed, "TypeError should not be raised"
-
-try:
-    long(IntLongMixClass())
-except TypeError:
-    raise TestFailed, "TypeError should not be raised"
-
-
 # Test correct errors from hash() on objects with comparisons but no __hash__
 
 class C0:
diff --git a/Lib/test/test_code.py b/Lib/test/test_code.py
index 7ee7dcd..6e0a181 100644
--- a/Lib/test/test_code.py
+++ b/Lib/test/test_code.py
@@ -70,7 +70,7 @@
 ...     'doc string'
 ...     'not a docstring'
 ...     53
-...     53L
+...     0x53
 
 >>> dump(optimize_away.func_code)
 name: optimize_away
diff --git a/Lib/test/test_compare.py b/Lib/test/test_compare.py
index 8f38e3b..1d0da69 100644
--- a/Lib/test/test_compare.py
+++ b/Lib/test/test_compare.py
@@ -17,7 +17,7 @@
         return self.arg == other
 
 class ComparisonTest(unittest.TestCase):
-    set1 = [2, 2.0, 2L, 2+0j, Cmp(2.0)]
+    set1 = [2, 2.0, 2, 2+0j, Cmp(2.0)]
     set2 = [[1], (3,), None, Empty()]
     candidates = set1 + set2
 
diff --git a/Lib/test/test_compile.py b/Lib/test/test_compile.py
index b517daa..1acb4a1 100644
--- a/Lib/test/test_compile.py
+++ b/Lib/test/test_compile.py
@@ -182,10 +182,8 @@
             self.assertRaises(SyntaxError, eval, arg)
 
         self.assertEqual(eval("0777"), 511)
-        self.assertEqual(eval("0777L"), 511)
         self.assertEqual(eval("000777"), 511)
         self.assertEqual(eval("0xff"), 255)
-        self.assertEqual(eval("0xffL"), 255)
         self.assertEqual(eval("0XfF"), 255)
         self.assertEqual(eval("0777."), 777)
         self.assertEqual(eval("0777.0"), 777)
@@ -212,19 +210,19 @@
         if sys.maxint == 2147483647:
             # 32-bit machine
             all_one_bits = '0xffffffff'
-            self.assertEqual(eval(all_one_bits), 4294967295L)
-            self.assertEqual(eval("-" + all_one_bits), -4294967295L)
+            self.assertEqual(eval(all_one_bits), 4294967295)
+            self.assertEqual(eval("-" + all_one_bits), -4294967295)
         elif sys.maxint == 9223372036854775807:
             # 64-bit machine
             all_one_bits = '0xffffffffffffffff'
-            self.assertEqual(eval(all_one_bits), 18446744073709551615L)
-            self.assertEqual(eval("-" + all_one_bits), -18446744073709551615L)
+            self.assertEqual(eval(all_one_bits), 18446744073709551615)
+            self.assertEqual(eval("-" + all_one_bits), -18446744073709551615)
         else:
             self.fail("How many bits *does* this machine have???")
         # Verify treatment of contant folding on -(sys.maxint+1)
         # i.e. -2147483648 on 32 bit platforms.  Should return int, not long.
         self.assertTrue(isinstance(eval("%s" % (-sys.maxint - 1)), int))
-        self.assertTrue(isinstance(eval("%s" % (-sys.maxint - 2)), long))
+        self.assertTrue(isinstance(eval("%s" % (-sys.maxint - 2)), int))
 
     if sys.maxint == 9223372036854775807:
         def test_32_63_bit_values(self):
diff --git a/Lib/test/test_complex.py b/Lib/test/test_complex.py
index 4aa799d..afc7cae 100644
--- a/Lib/test/test_complex.py
+++ b/Lib/test/test_complex.py
@@ -93,7 +93,7 @@
         self.assertRaises(ZeroDivisionError, complex.__floordiv__, 3+0j, 0+0j)
 
     def test_richcompare(self):
-        self.assertRaises(OverflowError, complex.__eq__, 1+1j, 1L<<10000)
+        self.assertRaises(OverflowError, complex.__eq__, 1+1j, 1<<10000)
         self.assertEqual(complex.__lt__(1+1j, None), NotImplemented)
         self.assertIs(complex.__eq__(1+1j, 1+1j), True)
         self.assertIs(complex.__eq__(1+1j, 2+2j), False)
@@ -180,25 +180,25 @@
         self.assertAlmostEqual(complex("1+10j"), 1+10j)
         self.assertAlmostEqual(complex(10), 10+0j)
         self.assertAlmostEqual(complex(10.0), 10+0j)
-        self.assertAlmostEqual(complex(10L), 10+0j)
+        self.assertAlmostEqual(complex(10), 10+0j)
         self.assertAlmostEqual(complex(10+0j), 10+0j)
         self.assertAlmostEqual(complex(1,10), 1+10j)
-        self.assertAlmostEqual(complex(1,10L), 1+10j)
+        self.assertAlmostEqual(complex(1,10), 1+10j)
         self.assertAlmostEqual(complex(1,10.0), 1+10j)
-        self.assertAlmostEqual(complex(1L,10), 1+10j)
-        self.assertAlmostEqual(complex(1L,10L), 1+10j)
-        self.assertAlmostEqual(complex(1L,10.0), 1+10j)
+        self.assertAlmostEqual(complex(1,10), 1+10j)
+        self.assertAlmostEqual(complex(1,10), 1+10j)
+        self.assertAlmostEqual(complex(1,10.0), 1+10j)
         self.assertAlmostEqual(complex(1.0,10), 1+10j)
-        self.assertAlmostEqual(complex(1.0,10L), 1+10j)
+        self.assertAlmostEqual(complex(1.0,10), 1+10j)
         self.assertAlmostEqual(complex(1.0,10.0), 1+10j)
         self.assertAlmostEqual(complex(3.14+0j), 3.14+0j)
         self.assertAlmostEqual(complex(3.14), 3.14+0j)
         self.assertAlmostEqual(complex(314), 314.0+0j)
-        self.assertAlmostEqual(complex(314L), 314.0+0j)
+        self.assertAlmostEqual(complex(314), 314.0+0j)
         self.assertAlmostEqual(complex(3.14+0j, 0j), 3.14+0j)
         self.assertAlmostEqual(complex(3.14, 0.0), 3.14+0j)
         self.assertAlmostEqual(complex(314, 0), 314.0+0j)
-        self.assertAlmostEqual(complex(314L, 0L), 314.0+0j)
+        self.assertAlmostEqual(complex(314, 0), 314.0+0j)
         self.assertAlmostEqual(complex(0j, 3.14j), -3.14+0j)
         self.assertAlmostEqual(complex(0.0, 3.14j), -3.14+0j)
         self.assertAlmostEqual(complex(0j, 3.14), 3.14j)
@@ -232,7 +232,7 @@
         self.assertRaises(ValueError, complex, '1+1j\0j')
 
         self.assertRaises(TypeError, int, 5+3j)
-        self.assertRaises(TypeError, long, 5+3j)
+        self.assertRaises(TypeError, int, 5+3j)
         self.assertRaises(TypeError, float, 5+3j)
         self.assertRaises(ValueError, complex, "")
         self.assertRaises(TypeError, complex, None)
diff --git a/Lib/test/test_cookielib.py b/Lib/test/test_cookielib.py
index 9b06869..cb9dffb 100644
--- a/Lib/test/test_cookielib.py
+++ b/Lib/test/test_cookielib.py
@@ -103,7 +103,7 @@
         from cookielib import parse_ns_headers
 
         # quotes should be stripped
-        expected = [[('foo', 'bar'), ('expires', 2209069412L), ('version', '0')]]
+        expected = [[('foo', 'bar'), ('expires', 2209069412), ('version', '0')]]
         for hdr in [
             'foo=bar; expires=01 Jan 2040 22:23:32 GMT',
             'foo=bar; expires="01 Jan 2040 22:23:32 GMT"',
diff --git a/Lib/test/test_copy.py b/Lib/test/test_copy.py
index 416a755..8a32866 100644
--- a/Lib/test/test_copy.py
+++ b/Lib/test/test_copy.py
@@ -82,7 +82,7 @@
             pass
         def f():
             pass
-        tests = [None, 42, 2L**100, 3.14, True, False, 1j,
+        tests = [None, 42, 2**100, 3.14, True, False, 1j,
                  "hello", u"hello\u1234", f.func_code,
                  NewStyle, xrange(10), Classic, max]
         for x in tests:
@@ -255,7 +255,7 @@
             pass
         def f():
             pass
-        tests = [None, 42, 2L**100, 3.14, True, False, 1j,
+        tests = [None, 42, 2**100, 3.14, True, False, 1j,
                  "hello", u"hello\u1234", f.func_code,
                  NewStyle, xrange(10), Classic, max]
         for x in tests:
diff --git a/Lib/test/test_copy_reg.py b/Lib/test/test_copy_reg.py
index c3d3964..34ca4ec 100644
--- a/Lib/test/test_copy_reg.py
+++ b/Lib/test/test_copy_reg.py
@@ -96,7 +96,7 @@
                 e.restore()
 
         # Ensure invalid codes blow up.
-        for code in -1, 0, 0x80000000L:
+        for code in -1, 0, 0x80000000:
             self.assertRaises(ValueError, copy_reg.add_extension,
                               mod, func, code)
 
diff --git a/Lib/test/test_datetime.py b/Lib/test/test_datetime.py
index 3329104..b32017e 100644
--- a/Lib/test/test_datetime.py
+++ b/Lib/test/test_datetime.py
@@ -32,7 +32,7 @@
 
 # An arbitrary collection of objects of non-datetime types, for testing
 # mixed-type comparisons.
-OTHERSTUFF = (10, 10L, 34.5, "abc", {}, [], ())
+OTHERSTUFF = (10, 10, 34.5, "abc", {}, [], ())
 
 
 #############################################################################
@@ -149,11 +149,11 @@
         self.failIf(() == me)
         self.failUnless(() != me)
 
-        self.failUnless(me in [1, 20L, [], me])
-        self.failIf(me not in [1, 20L, [], me])
+        self.failUnless(me in [1, 20, [], me])
+        self.failIf(me not in [1, 20, [], me])
 
-        self.failUnless([] in [me, 1, 20L, []])
-        self.failIf([] not in [me, 1, 20L, []])
+        self.failUnless([] in [me, 1, 20, []])
+        self.failIf([] not in [me, 1, 20, []])
 
     def test_harmful_mixed_comparison(self):
         me = self.theclass(1, 1, 1)
@@ -222,13 +222,13 @@
         eq(td(0, 0, 60*1000000), b)
         eq(a*10, td(70))
         eq(a*10, 10*a)
-        eq(a*10L, 10*a)
+        eq(a*10, 10*a)
         eq(b*10, td(0, 600))
         eq(10*b, td(0, 600))
-        eq(b*10L, td(0, 600))
+        eq(b*10, td(0, 600))
         eq(c*10, td(0, 0, 10000))
         eq(10*c, td(0, 0, 10000))
-        eq(c*10L, td(0, 0, 10000))
+        eq(c*10, td(0, 0, 10000))
         eq(a*-1, -a)
         eq(b*-2, -b-b)
         eq(c*-2, -c+-c)
@@ -246,7 +246,7 @@
         a = timedelta(42)
 
         # Add/sub ints, longs, floats should be illegal
-        for i in 1, 1L, 1.0:
+        for i in 1, 1, 1.0:
             self.assertRaises(TypeError, lambda: a+i)
             self.assertRaises(TypeError, lambda: a-i)
             self.assertRaises(TypeError, lambda: i+a)
@@ -263,7 +263,7 @@
 
         # Divison of int by timedelta doesn't make sense.
         # Division by zero doesn't make sense.
-        for zero in 0, 0L:
+        for zero in 0, 0:
             self.assertRaises(TypeError, lambda: zero // a)
             self.assertRaises(ZeroDivisionError, lambda: a // zero)
 
@@ -696,7 +696,7 @@
         self.assertEqual(a - (a - day), day)
 
         # Add/sub ints, longs, floats should be illegal
-        for i in 1, 1L, 1.0:
+        for i in 1, 1, 1.0:
             self.assertRaises(TypeError, lambda: a+i)
             self.assertRaises(TypeError, lambda: a-i)
             self.assertRaises(TypeError, lambda: i+a)
@@ -1325,7 +1325,7 @@
         self.assertEqual(a - (week + day + hour + millisec),
                          (((a - week) - day) - hour) - millisec)
         # Add/sub ints, longs, floats should be illegal
-        for i in 1, 1L, 1.0:
+        for i in 1, 1, 1.0:
             self.assertRaises(TypeError, lambda: a+i)
             self.assertRaises(TypeError, lambda: a-i)
             self.assertRaises(TypeError, lambda: i+a)
diff --git a/Lib/test/test_decimal.py b/Lib/test/test_decimal.py
index f9a9e82..4a53122 100644
--- a/Lib/test/test_decimal.py
+++ b/Lib/test/test_decimal.py
@@ -907,8 +907,8 @@
         self.assertEqual(int(d2), 15)
 
         #long
-        self.assertEqual(long(d1), 66)
-        self.assertEqual(long(d2), 15)
+        self.assertEqual(int(d1), 66)
+        self.assertEqual(int(d2), 15)
 
         #float
         self.assertEqual(float(d1), 66)
diff --git a/Lib/test/test_descr.py b/Lib/test/test_descr.py
index bc95226..bcfadf7 100644
--- a/Lib/test/test_descr.py
+++ b/Lib/test/test_descr.py
@@ -191,7 +191,7 @@
     vereq(d, dict([("two", 2)], one=1))
     vereq(d, dict([("one", 100), ("two", 200)], **d))
     verify(d is not dict(**d))
-    for badarg in 0, 0L, 0j, "0", [0], (0,):
+    for badarg in 0, 0, 0j, "0", [0], (0,):
         try:
             dict(badarg)
         except TypeError:
@@ -264,7 +264,7 @@
     del junk
 
     # Just make sure these don't blow up!
-    for arg in 2, 2L, 2j, 2e0, [2], "2", u"2", (2,), {2:2}, type, test_dir:
+    for arg in 2, 2, 2j, 2e0, [2], "2", u"2", (2,), {2:2}, type, test_dir:
         dir(arg)
 
     # Test dir on custom classes. Since these have object as a
@@ -385,7 +385,6 @@
     'abs': 'abs',
     'invert': '~',
     'int': 'int',
-    'long': 'long',
     'float': 'float',
     'oct': 'oct',
     'hex': 'hex',
@@ -423,7 +422,7 @@
     class C(int):
         def __add__(self, other):
             return NotImplemented
-    vereq(C(5L), 5)
+    vereq(C(5), 5)
     try:
         C() + ""
     except TypeError:
@@ -433,7 +432,7 @@
 
 def longs():
     if verbose: print "Testing long operations..."
-    numops(100L, 3L)
+    numops(100, 3)
 
 def floats():
     if verbose: print "Testing float operations..."
@@ -1263,10 +1262,10 @@
     vereq(I(3)*I(2), 6)
 
     # Test handling of long*seq and seq*long
-    class L(long):
+    class L(int):
         pass
-    vereq("a"*L(2L), "aa")
-    vereq(L(2L)*"a", "aa")
+    vereq("a"*L(2), "aa")
+    vereq(L(2)*"a", "aa")
     vereq(2*L(3), 6)
     vereq(L(3)*2, 6)
     vereq(L(3)*L(2), 6)
@@ -2041,7 +2040,7 @@
     verify((hexint(0) << 12).__class__ is int)
     verify((hexint(0) >> 12).__class__ is int)
 
-    class octlong(long):
+    class octlong(int):
         __slots__ = []
         def __str__(self):
             s = oct(self)
@@ -2056,39 +2055,39 @@
     # because the example uses a short int left argument.)
     vereq(str(5 + octlong(3000)), "05675")
     a = octlong(12345)
-    vereq(a, 12345L)
-    vereq(long(a), 12345L)
-    vereq(hash(a), hash(12345L))
-    verify(long(a).__class__ is long)
-    verify((+a).__class__ is long)
-    verify((-a).__class__ is long)
-    verify((-octlong(0)).__class__ is long)
-    verify((a >> 0).__class__ is long)
-    verify((a << 0).__class__ is long)
-    verify((a - 0).__class__ is long)
-    verify((a * 1).__class__ is long)
-    verify((a ** 1).__class__ is long)
-    verify((a // 1).__class__ is long)
-    verify((1 * a).__class__ is long)
-    verify((a | 0).__class__ is long)
-    verify((a ^ 0).__class__ is long)
-    verify((a & -1L).__class__ is long)
-    verify((octlong(0) << 12).__class__ is long)
-    verify((octlong(0) >> 12).__class__ is long)
-    verify(abs(octlong(0)).__class__ is long)
+    vereq(a, 12345)
+    vereq(int(a), 12345)
+    vereq(hash(a), hash(12345))
+    verify(int(a).__class__ is int)
+    verify((+a).__class__ is int)
+    verify((-a).__class__ is int)
+    verify((-octlong(0)).__class__ is int)
+    verify((a >> 0).__class__ is int)
+    verify((a << 0).__class__ is int)
+    verify((a - 0).__class__ is int)
+    verify((a * 1).__class__ is int)
+    verify((a ** 1).__class__ is int)
+    verify((a // 1).__class__ is int)
+    verify((1 * a).__class__ is int)
+    verify((a | 0).__class__ is int)
+    verify((a ^ 0).__class__ is int)
+    verify((a & -1).__class__ is int)
+    verify((octlong(0) << 12).__class__ is int)
+    verify((octlong(0) >> 12).__class__ is int)
+    verify(abs(octlong(0)).__class__ is int)
 
     # Because octlong overrides __add__, we can't check the absence of +0
     # optimizations using octlong.
-    class longclone(long):
+    class longclone(int):
         pass
     a = longclone(1)
-    verify((a + 0).__class__ is long)
-    verify((0 + a).__class__ is long)
+    verify((a + 0).__class__ is int)
+    verify((0 + a).__class__ is int)
 
     # Check that negative clones don't segfault
     a = longclone(-1)
     vereq(a.__dict__, {})
-    vereq(long(a), -1)  # verify PyNumber_Long() copies the sign bit
+    vereq(int(a), -1)  # verify PyNumber_Long() copies the sign bit
 
     class precfloat(float):
         __slots__ = ['prec']
@@ -2366,7 +2365,7 @@
         print "Testing keyword args to basic type constructors ..."
     vereq(int(x=1), 1)
     vereq(float(x=2), 2.0)
-    vereq(long(x=3), 3L)
+    vereq(int(x=3), 3)
     vereq(complex(imag=42, real=666), complex(666, 42))
     vereq(str(object=500), '500')
     vereq(unicode(string='abc', errors='strict'), u'abc')
@@ -2374,7 +2373,7 @@
     vereq(list(sequence=(0, 1, 2)), range(3))
     # note: as of Python 2.3, dict() no longer has an "items" keyword arg
 
-    for constructor in (int, float, long, complex, str, unicode,
+    for constructor in (int, float, int, complex, str, unicode,
                         tuple, list, file):
         try:
             constructor(bogus_keyword_arg=1)
@@ -2472,37 +2471,37 @@
             def __eq__(self, other):
                 if isinstance(other, C):
                     return self.value == other.value
-                if isinstance(other, int) or isinstance(other, long):
+                if isinstance(other, int) or isinstance(other, int):
                     return self.value == other
                 return NotImplemented
             def __ne__(self, other):
                 if isinstance(other, C):
                     return self.value != other.value
-                if isinstance(other, int) or isinstance(other, long):
+                if isinstance(other, int) or isinstance(other, int):
                     return self.value != other
                 return NotImplemented
             def __lt__(self, other):
                 if isinstance(other, C):
                     return self.value < other.value
-                if isinstance(other, int) or isinstance(other, long):
+                if isinstance(other, int) or isinstance(other, int):
                     return self.value < other
                 return NotImplemented
             def __le__(self, other):
                 if isinstance(other, C):
                     return self.value <= other.value
-                if isinstance(other, int) or isinstance(other, long):
+                if isinstance(other, int) or isinstance(other, int):
                     return self.value <= other
                 return NotImplemented
             def __gt__(self, other):
                 if isinstance(other, C):
                     return self.value > other.value
-                if isinstance(other, int) or isinstance(other, long):
+                if isinstance(other, int) or isinstance(other, int):
                     return self.value > other
                 return NotImplemented
             def __ge__(self, other):
                 if isinstance(other, C):
                     return self.value >= other.value
-                if isinstance(other, int) or isinstance(other, long):
+                if isinstance(other, int) or isinstance(other, int):
                     return self.value >= other
                 return NotImplemented
 
@@ -2550,37 +2549,37 @@
             def __eq__(self, other):
                 if isinstance(other, C):
                     return self.value == other.value
-                if isinstance(other, int) or isinstance(other, long):
+                if isinstance(other, int) or isinstance(other, int):
                     return self.value == other
                 return NotImplemented
             def __ne__(self, other):
                 if isinstance(other, C):
                     return self.value != other.value
-                if isinstance(other, int) or isinstance(other, long):
+                if isinstance(other, int) or isinstance(other, int):
                     return self.value != other
                 return NotImplemented
             def __lt__(self, other):
                 if isinstance(other, C):
                     return self.value < other.value
-                if isinstance(other, int) or isinstance(other, long):
+                if isinstance(other, int) or isinstance(other, int):
                     return self.value < other
                 return NotImplemented
             def __le__(self, other):
                 if isinstance(other, C):
                     return self.value <= other.value
-                if isinstance(other, int) or isinstance(other, long):
+                if isinstance(other, int) or isinstance(other, int):
                     return self.value <= other
                 return NotImplemented
             def __gt__(self, other):
                 if isinstance(other, C):
                     return self.value > other.value
-                if isinstance(other, int) or isinstance(other, long):
+                if isinstance(other, int) or isinstance(other, int):
                     return self.value > other
                 return NotImplemented
             def __ge__(self, other):
                 if isinstance(other, C):
                     return self.value >= other.value
-                if isinstance(other, int) or isinstance(other, long):
+                if isinstance(other, int) or isinstance(other, int):
                     return self.value >= other
                 return NotImplemented
         c1 = C(1)
@@ -3250,11 +3249,11 @@
     y *= 2
     vereq(y, (x, 2))
     y = x
-    y *= 3L
-    vereq(y, (x, 3L))
+    y *= 3
+    vereq(y, (x, 3))
     y = x
-    y *= 1L<<100
-    vereq(y, (x, 1L<<100))
+    y *= 1<<100
+    vereq(y, (x, 1<<100))
     y = x
     y *= None
     vereq(y, (x, None))
@@ -3444,7 +3443,7 @@
         def __pow__(self, *args):
             pass
     try:
-        pow(0L, UserLong(), 0L)
+        pow(0, UserLong(), 0)
     except:
         pass
 
@@ -3956,7 +3955,7 @@
         else:
             raise TestFailed("no TypeError from %r" % (expr,))
 
-    N1 = sys.maxint + 1L    # might trigger OverflowErrors instead of TypeErrors
+    N1 = sys.maxint + 1    # might trigger OverflowErrors instead of TypeErrors
     N2 = sys.maxint         # if sizeof(int) < sizeof(long), might trigger
                             #   ValueErrors instead of TypeErrors
     for metaclass in [type, types.ClassType]:
diff --git a/Lib/test/test_dict.py b/Lib/test/test_dict.py
index c7fa15d..1042cb1 100644
--- a/Lib/test/test_dict.py
+++ b/Lib/test/test_dict.py
@@ -314,7 +314,7 @@
 
         # verify longs/ints get same value when key > 32 bits (for 64-bit archs)
         # see SF bug #689659
-        x = 4503599627370496L
+        x = 4503599627370496
         y = 4503599627370496
         h = {x: 'anything', y: 'something else'}
         self.assertEqual(h[x], h[y])
@@ -371,7 +371,7 @@
 
     def test_eq(self):
         self.assertEqual({}, {})
-        self.assertEqual({1: 2}, {1L: 2L})
+        self.assertEqual({1: 2}, {1: 2})
 
         class Exc(Exception): pass
 
diff --git a/Lib/test/test_format.py b/Lib/test/test_format.py
index fc8a5a1..df78a32 100644
--- a/Lib/test/test_format.py
+++ b/Lib/test/test_format.py
@@ -57,14 +57,14 @@
 
 # Formatting of long integers. Overflow is not ok
 overflowok = 0
-testboth("%x", 10L, "a")
-testboth("%x", 100000000000L, "174876e800")
-testboth("%o", 10L, "12")
-testboth("%o", 100000000000L, "1351035564000")
-testboth("%d", 10L, "10")
-testboth("%d", 100000000000L, "100000000000")
+testboth("%x", 10, "a")
+testboth("%x", 100000000000, "174876e800")
+testboth("%o", 10, "12")
+testboth("%o", 100000000000, "1351035564000")
+testboth("%d", 10, "10")
+testboth("%d", 100000000000, "100000000000")
 
-big = 123456789012345678901234567890L
+big = 123456789012345678901234567890
 testboth("%d", big, "123456789012345678901234567890")
 testboth("%d", -big, "-123456789012345678901234567890")
 testboth("%5d", -big, "-123456789012345678901234567890")
@@ -83,7 +83,7 @@
 testboth("%.31d", big, "0123456789012345678901234567890")
 testboth("%32.31d", big, " 0123456789012345678901234567890")
 
-big = 0x1234567890abcdef12345L  # 21 hex digits
+big = 0x1234567890abcdef12345  # 21 hex digits
 testboth("%x", big, "1234567890abcdef12345")
 testboth("%x", -big, "-1234567890abcdef12345")
 testboth("%5x", -big, "-1234567890abcdef12345")
@@ -120,7 +120,7 @@
 # same, except no 0 flag
 testboth("%#+27.23X", big, " +0X001234567890ABCDEF12345")
 
-big = 012345670123456701234567012345670L  # 32 octal digits
+big = 012345670123456701234567012345670  # 32 octal digits
 testboth("%o", big, "12345670123456701234567012345670")
 testboth("%o", -big, "-12345670123456701234567012345670")
 testboth("%5o", -big, "-12345670123456701234567012345670")
@@ -163,34 +163,34 @@
 # Some small ints, in both Python int and long flavors).
 testboth("%d", 42, "42")
 testboth("%d", -42, "-42")
-testboth("%d", 42L, "42")
-testboth("%d", -42L, "-42")
+testboth("%d", 42, "42")
+testboth("%d", -42, "-42")
 testboth("%#x", 1, "0x1")
-testboth("%#x", 1L, "0x1")
+testboth("%#x", 1, "0x1")
 testboth("%#X", 1, "0X1")
-testboth("%#X", 1L, "0X1")
+testboth("%#X", 1, "0X1")
 testboth("%#o", 1, "01")
-testboth("%#o", 1L, "01")
+testboth("%#o", 1, "01")
 testboth("%#o", 0, "0")
-testboth("%#o", 0L, "0")
+testboth("%#o", 0, "0")
 testboth("%o", 0, "0")
-testboth("%o", 0L, "0")
+testboth("%o", 0, "0")
 testboth("%d", 0, "0")
-testboth("%d", 0L, "0")
+testboth("%d", 0, "0")
 testboth("%#x", 0, "0x0")
-testboth("%#x", 0L, "0x0")
+testboth("%#x", 0, "0x0")
 testboth("%#X", 0, "0X0")
-testboth("%#X", 0L, "0X0")
+testboth("%#X", 0, "0X0")
 
 testboth("%x", 0x42, "42")
 testboth("%x", -0x42, "-42")
-testboth("%x", 0x42L, "42")
-testboth("%x", -0x42L, "-42")
+testboth("%x", 0x42, "42")
+testboth("%x", -0x42, "-42")
 
 testboth("%o", 042, "42")
 testboth("%o", -042, "-42")
-testboth("%o", 042L, "42")
-testboth("%o", -042L, "-42")
+testboth("%o", 042, "42")
+testboth("%o", -042, "-42")
 
 # Test exception for unknown format characters
 if verbose:
@@ -230,7 +230,7 @@
 test_exc(u'no format', u'1', TypeError,
          "not all arguments converted during string formatting")
 
-class Foobar(long):
+class Foobar(int):
     def __oct__(self):
         # Returning a non-string should not blow up.
         return self + 1
diff --git a/Lib/test/test_functools.py b/Lib/test/test_functools.py
index edc17fc..828331e 100644
--- a/Lib/test/test_functools.py
+++ b/Lib/test/test_functools.py
@@ -293,8 +293,8 @@
         )
         self.assertEqual(self.func(lambda x, y: x*y, range(2,8), 1), 5040)
         self.assertEqual(
-            self.func(lambda x, y: x*y, range(2,21), 1L),
-            2432902008176640000L
+            self.func(lambda x, y: x*y, range(2,21), 1),
+            2432902008176640000
         )
         self.assertEqual(self.func(lambda x, y: x+y, Squares(10)), 285)
         self.assertEqual(self.func(lambda x, y: x+y, Squares(10), 0), 285)
diff --git a/Lib/test/test_generators.py b/Lib/test/test_generators.py
index 30df034..a40d8ea 100644
--- a/Lib/test/test_generators.py
+++ b/Lib/test/test_generators.py
@@ -1057,9 +1057,9 @@
         # generates the possiblities for the columns in that row.
         self.rowgenerators = []
         for i in rangen:
-            rowuses = [(1L << j) |                  # column ordinal
-                       (1L << (n + i-j + n-1)) |    # NW-SE ordinal
-                       (1L << (n + 2*n-1 + i+j))    # NE-SW ordinal
+            rowuses = [(1 << j) |                  # column ordinal
+                       (1 << (n + i-j + n-1)) |    # NW-SE ordinal
+                       (1 << (n + 2*n-1 + i+j))    # NE-SW ordinal
                             for j in rangen]
 
             def rowgen(rowuses=rowuses):
diff --git a/Lib/test/test_getargs2.py b/Lib/test/test_getargs2.py
index c428f45..9172576 100644
--- a/Lib/test/test_getargs2.py
+++ b/Lib/test/test_getargs2.py
@@ -45,7 +45,7 @@
 """
 
 LARGE = 0x7FFFFFFF
-VERY_LARGE = 0xFF0000121212121212121242L
+VERY_LARGE = 0xFF0000121212121212121242
 
 from _testcapi import UCHAR_MAX, USHRT_MAX, UINT_MAX, ULONG_MAX, INT_MAX, \
      INT_MIN, LONG_MIN, LONG_MAX, PY_SSIZE_T_MIN, PY_SSIZE_T_MAX
@@ -57,7 +57,7 @@
 
 class Long:
     def __int__(self):
-        return 99L
+        return 99
 
 class Int:
     def __int__(self):
@@ -77,7 +77,7 @@
         self.assertRaises(OverflowError, getargs_b, UCHAR_MAX + 1)
 
         self.failUnlessEqual(42, getargs_b(42))
-        self.failUnlessEqual(42, getargs_b(42L))
+        self.failUnlessEqual(42, getargs_b(42))
         self.assertRaises(OverflowError, getargs_b, VERY_LARGE)
 
     def test_B(self):
@@ -88,13 +88,13 @@
         self.failUnlessEqual(99, getargs_B(Int()))
 
         self.failUnlessEqual(UCHAR_MAX, getargs_B(-1))
-        self.failUnlessEqual(UCHAR_MAX, getargs_B(-1L))
+        self.failUnlessEqual(UCHAR_MAX, getargs_B(-1))
         self.failUnlessEqual(0, getargs_B(0))
         self.failUnlessEqual(UCHAR_MAX, getargs_B(UCHAR_MAX))
         self.failUnlessEqual(0, getargs_B(UCHAR_MAX+1))
 
         self.failUnlessEqual(42, getargs_B(42))
-        self.failUnlessEqual(42, getargs_B(42L))
+        self.failUnlessEqual(42, getargs_B(42))
         self.failUnlessEqual(UCHAR_MAX & VERY_LARGE, getargs_B(VERY_LARGE))
 
     def test_H(self):
@@ -110,7 +110,7 @@
         self.failUnlessEqual(0, getargs_H(USHRT_MAX+1))
 
         self.failUnlessEqual(42, getargs_H(42))
-        self.failUnlessEqual(42, getargs_H(42L))
+        self.failUnlessEqual(42, getargs_H(42))
 
         self.failUnlessEqual(VERY_LARGE & USHRT_MAX, getargs_H(VERY_LARGE))
 
@@ -127,7 +127,7 @@
         self.failUnlessEqual(0, getargs_I(UINT_MAX+1))
 
         self.failUnlessEqual(42, getargs_I(42))
-        self.failUnlessEqual(42, getargs_I(42L))
+        self.failUnlessEqual(42, getargs_I(42))
 
         self.failUnlessEqual(VERY_LARGE & UINT_MAX, getargs_I(VERY_LARGE))
 
@@ -145,7 +145,7 @@
         self.failUnlessEqual(0, getargs_k(ULONG_MAX+1))
 
         self.failUnlessEqual(42, getargs_k(42))
-        self.failUnlessEqual(42, getargs_k(42L))
+        self.failUnlessEqual(42, getargs_k(42))
 
         self.failUnlessEqual(VERY_LARGE & ULONG_MAX, getargs_k(VERY_LARGE))
 
@@ -163,7 +163,7 @@
         self.assertRaises(OverflowError, getargs_i, INT_MAX+1)
 
         self.failUnlessEqual(42, getargs_i(42))
-        self.failUnlessEqual(42, getargs_i(42L))
+        self.failUnlessEqual(42, getargs_i(42))
         self.assertRaises(OverflowError, getargs_i, VERY_LARGE)
 
     def test_l(self):
@@ -179,7 +179,7 @@
         self.assertRaises(OverflowError, getargs_l, LONG_MAX+1)
 
         self.failUnlessEqual(42, getargs_l(42))
-        self.failUnlessEqual(42, getargs_l(42L))
+        self.failUnlessEqual(42, getargs_l(42))
         self.assertRaises(OverflowError, getargs_l, VERY_LARGE)
 
     def test_n(self):
@@ -196,7 +196,7 @@
         self.assertRaises(OverflowError, getargs_n, PY_SSIZE_T_MAX+1)
 
         self.failUnlessEqual(42, getargs_n(42))
-        self.failUnlessEqual(42, getargs_n(42L))
+        self.failUnlessEqual(42, getargs_n(42))
         self.assertRaises(OverflowError, getargs_n, VERY_LARGE)
 
 
@@ -215,7 +215,7 @@
         self.assertRaises(OverflowError, getargs_L, LLONG_MAX+1)
 
         self.failUnlessEqual(42, getargs_L(42))
-        self.failUnlessEqual(42, getargs_L(42L))
+        self.failUnlessEqual(42, getargs_L(42))
         self.assertRaises(OverflowError, getargs_L, VERY_LARGE)
 
     def test_K(self):
@@ -229,7 +229,7 @@
         self.failUnlessEqual(0, getargs_K(ULLONG_MAX+1))
 
         self.failUnlessEqual(42, getargs_K(42))
-        self.failUnlessEqual(42, getargs_K(42L))
+        self.failUnlessEqual(42, getargs_K(42))
 
         self.failUnlessEqual(VERY_LARGE & ULLONG_MAX, getargs_K(VERY_LARGE))
 
diff --git a/Lib/test/test_grammar.py b/Lib/test/test_grammar.py
index 0d36a62..33bfd32 100644
--- a/Lib/test/test_grammar.py
+++ b/Lib/test/test_grammar.py
@@ -55,14 +55,14 @@
             self.fail('Weird maxint value %r' % maxint)
 
     def testLongIntegers(self):
-        x = 0L
-        x = 0l
-        x = 0xffffffffffffffffL
-        x = 0xffffffffffffffffl
-        x = 077777777777777777L
-        x = 077777777777777777l
-        x = 123456789012345678901234567890L
-        x = 123456789012345678901234567890l
+        x = 0
+        x = 0
+        x = 0xffffffffffffffff
+        x = 0xffffffffffffffff
+        x = 077777777777777777
+        x = 077777777777777777
+        x = 123456789012345678901234567890
+        x = 123456789012345678901234567890
 
     def testFloats(self):
         x = 3.14
@@ -327,7 +327,7 @@
         l1 = lambda : 0
         self.assertEquals(l1(), 0)
         l2 = lambda : a[d] # XXX just testing the expression
-        l3 = lambda : [2 < x for x in [-1, 3, 0L]]
+        l3 = lambda : [2 < x for x in [-1, 3, 0]]
         self.assertEquals(l3(), [0, 1, 0])
         l4 = lambda x = lambda y = lambda z=1 : z : y() : x()
         self.assertEquals(l4(), 1)
diff --git a/Lib/test/test_hash.py b/Lib/test/test_hash.py
index 3d6c9d1..9578537 100644
--- a/Lib/test/test_hash.py
+++ b/Lib/test/test_hash.py
@@ -17,14 +17,14 @@
                 self.fail("hashed values differ: %r" % (objlist,))
 
     def test_numeric_literals(self):
-        self.same_hash(1, 1L, 1.0, 1.0+0.0j)
+        self.same_hash(1, 1, 1.0, 1.0+0.0j)
 
     def test_coerced_integers(self):
-        self.same_hash(int(1), long(1), float(1), complex(1),
+        self.same_hash(int(1), int(1), float(1), complex(1),
                        int('1'), float('1.0'))
 
     def test_coerced_floats(self):
-        self.same_hash(long(1.23e300), float(1.23e300))
+        self.same_hash(int(1.23e300), float(1.23e300))
         self.same_hash(float(0.5), complex(0.5, 0.0))
 
 
diff --git a/Lib/test/test_hexoct.py b/Lib/test/test_hexoct.py
index f71dbe0..5e86bea 100644
--- a/Lib/test/test_hexoct.py
+++ b/Lib/test/test_hexoct.py
@@ -41,26 +41,26 @@
     def test_hex_unsigned(self):
         if platform_long_is_32_bits:
             # Positive constants
-            self.assertEqual(0x80000000, 2147483648L)
-            self.assertEqual(0xffffffff, 4294967295L)
+            self.assertEqual(0x80000000, 2147483648)
+            self.assertEqual(0xffffffff, 4294967295)
             # Ditto with a minus sign and parentheses
-            self.assertEqual(-(0x80000000), -2147483648L)
-            self.assertEqual(-(0xffffffff), -4294967295L)
+            self.assertEqual(-(0x80000000), -2147483648)
+            self.assertEqual(-(0xffffffff), -4294967295)
             # Ditto with a minus sign and NO parentheses
             # This failed in Python 2.2 through 2.2.2 and in 2.3a1
-            self.assertEqual(-0x80000000, -2147483648L)
-            self.assertEqual(-0xffffffff, -4294967295L)
+            self.assertEqual(-0x80000000, -2147483648)
+            self.assertEqual(-0xffffffff, -4294967295)
         else:
             # Positive constants
-            self.assertEqual(0x8000000000000000, 9223372036854775808L)
-            self.assertEqual(0xffffffffffffffff, 18446744073709551615L)
+            self.assertEqual(0x8000000000000000, 9223372036854775808)
+            self.assertEqual(0xffffffffffffffff, 18446744073709551615)
             # Ditto with a minus sign and parentheses
-            self.assertEqual(-(0x8000000000000000), -9223372036854775808L)
-            self.assertEqual(-(0xffffffffffffffff), -18446744073709551615L)
+            self.assertEqual(-(0x8000000000000000), -9223372036854775808)
+            self.assertEqual(-(0xffffffffffffffff), -18446744073709551615)
             # Ditto with a minus sign and NO parentheses
             # This failed in Python 2.2 through 2.2.2 and in 2.3a1
-            self.assertEqual(-0x8000000000000000, -9223372036854775808L)
-            self.assertEqual(-0xffffffffffffffff, -18446744073709551615L)
+            self.assertEqual(-0x8000000000000000, -9223372036854775808)
+            self.assertEqual(-0xffffffffffffffff, -18446744073709551615)
 
     def test_oct_baseline(self):
         # Baseline tests
@@ -88,26 +88,26 @@
     def test_oct_unsigned(self):
         if platform_long_is_32_bits:
             # Positive constants
-            self.assertEqual(020000000000, 2147483648L)
-            self.assertEqual(037777777777, 4294967295L)
+            self.assertEqual(020000000000, 2147483648)
+            self.assertEqual(037777777777, 4294967295)
             # Ditto with a minus sign and parentheses
-            self.assertEqual(-(020000000000), -2147483648L)
-            self.assertEqual(-(037777777777), -4294967295L)
+            self.assertEqual(-(020000000000), -2147483648)
+            self.assertEqual(-(037777777777), -4294967295)
             # Ditto with a minus sign and NO parentheses
             # This failed in Python 2.2 through 2.2.2 and in 2.3a1
-            self.assertEqual(-020000000000, -2147483648L)
-            self.assertEqual(-037777777777, -4294967295L)
+            self.assertEqual(-020000000000, -2147483648)
+            self.assertEqual(-037777777777, -4294967295)
         else:
             # Positive constants
-            self.assertEqual(01000000000000000000000, 9223372036854775808L)
-            self.assertEqual(01777777777777777777777, 18446744073709551615L)
+            self.assertEqual(01000000000000000000000, 9223372036854775808)
+            self.assertEqual(01777777777777777777777, 18446744073709551615)
             # Ditto with a minus sign and parentheses
-            self.assertEqual(-(01000000000000000000000), -9223372036854775808L)
-            self.assertEqual(-(01777777777777777777777), -18446744073709551615L)
+            self.assertEqual(-(01000000000000000000000), -9223372036854775808)
+            self.assertEqual(-(01777777777777777777777), -18446744073709551615)
             # Ditto with a minus sign and NO parentheses
             # This failed in Python 2.2 through 2.2.2 and in 2.3a1
-            self.assertEqual(-01000000000000000000000, -9223372036854775808L)
-            self.assertEqual(-01777777777777777777777, -18446744073709551615L)
+            self.assertEqual(-01000000000000000000000, -9223372036854775808)
+            self.assertEqual(-01777777777777777777777, -18446744073709551615)
 
 def test_main():
     test_support.run_unittest(TextHexOct)
diff --git a/Lib/test/test_index.py b/Lib/test/test_index.py
index ecb566d..0045469 100644
--- a/Lib/test/test_index.py
+++ b/Lib/test/test_index.py
@@ -15,7 +15,7 @@
     def __index__(self):
         return self
 
-class TrapLong(long):
+class TrapLong(int):
     def __index__(self):
         return self
 
@@ -44,7 +44,7 @@
         self.o.ind = 4
         self.n.ind = 5
         self.assertEqual(6 .__index__(), 6)
-        self.assertEqual(-7L.__index__(), -7)
+        self.assertEqual(-7 .__index__(), -7)
         self.assertEqual(self.o.__index__(), 4)
         self.assertEqual(self.n.__index__(), 5)
 
diff --git a/Lib/test/test_isinstance.py b/Lib/test/test_isinstance.py
index 25b0816..cc2b5fd 100644
--- a/Lib/test/test_isinstance.py
+++ b/Lib/test/test_isinstance.py
@@ -242,7 +242,7 @@
         self.assertEqual(False, issubclass(NewChild, ()))
         self.assertEqual(True, issubclass(NewSuper, (NewChild, (NewSuper,))))
 
-        self.assertEqual(True, issubclass(int, (long, (float, int))))
+        self.assertEqual(True, issubclass(int, (int, (float, int))))
         if test_support.have_unicode:
             self.assertEqual(True, issubclass(str, (unicode, (Child, NewChild, basestring))))
 
diff --git a/Lib/test/test_largefile.py b/Lib/test/test_largefile.py
index 4dca97f..d7ed1b3 100644
--- a/Lib/test/test_largefile.py
+++ b/Lib/test/test_largefile.py
@@ -19,7 +19,7 @@
 
 
 # create >2GB file (2GB = 2147483648 bytes)
-size = 2500000000L
+size = 2500000000
 name = test_support.TESTFN
 
 
@@ -37,7 +37,7 @@
     f = open(test_support.TESTFN, 'wb')
     try:
         # 2**31 == 2147483648
-        f.seek(2147483649L)
+        f.seek(2147483649)
         # Seeking is not enough of a test: you must write and flush, too!
         f.write("x")
         f.flush()
diff --git a/Lib/test/test_long.py b/Lib/test/test_long.py
index e0c781f..2876f83 100644
--- a/Lib/test/test_long.py
+++ b/Lib/test/test_long.py
@@ -23,11 +23,11 @@
 MAXDIGITS = 15
 
 # build some special values
-special = map(long, [0, 1, 2, BASE, BASE >> 1])
-special.append(0x5555555555555555L)
-special.append(0xaaaaaaaaaaaaaaaaL)
+special = map(int, [0, 1, 2, BASE, BASE >> 1])
+special.append(0x5555555555555555)
+special.append(0xaaaaaaaaaaaaaaaa)
 #  some solid strings of one bits
-p2 = 4L  # 0 and 1 already added
+p2 = 4  # 0 and 1 already added
 for i in range(2*SHIFT):
     special.append(p2 - 1)
     p2 = p2 << 1
@@ -49,7 +49,7 @@
         self.assert_(ndigits > 0)
         nbits_hi = ndigits * SHIFT
         nbits_lo = nbits_hi - SHIFT + 1
-        answer = 0L
+        answer = 0
         nbits = 0
         r = int(random.random() * (SHIFT * 2)) | 1  # force 1 bits to start
         while nbits < nbits_lo:
@@ -70,7 +70,7 @@
     # BASE).  The sign bit is also random.
 
     def getran2(ndigits):
-        answer = 0L
+        answer = 0
         for i in xrange(ndigits):
             answer = (answer << SHIFT) | random.randint(0, MASK)
         if random.random() < 0.5:
@@ -98,7 +98,7 @@
         for lenx in digits:
             x = self.getran(lenx)
             for leny in digits:
-                y = self.getran(leny) or 1L
+                y = self.getran(leny) or 1
                 self.check_division(x, y)
 
     def test_karatsuba(self):
@@ -110,15 +110,15 @@
         # Test products of long strings of 1 bits -- (2**x-1)*(2**y-1) ==
         # 2**(x+y) - 2**x - 2**y + 1, so the proper result is easy to check.
         for abits in bits:
-            a = (1L << abits) - 1
+            a = (1 << abits) - 1
             for bbits in bits:
                 if bbits < abits:
                     continue
-                b = (1L << bbits) - 1
+                b = (1 << bbits) - 1
                 x = a * b
-                y = ((1L << (abits + bbits)) -
-                     (1L << abits) -
-                     (1L << bbits) +
+                y = ((1 << (abits + bbits)) -
+                     (1 << abits) -
+                     (1 << bbits) +
                      1)
                 self.assertEqual(x, y,
                     Frm("bad result for a*b: a=%r, b=%r, x=%r, y=%r", a, b, x, y))
@@ -141,7 +141,7 @@
         eq(-x, 1 + ~x, Frm("not -x == 1 + ~x for x=%r", x))
         eq(-x, ~(x-1), Frm("not -x == ~(x-1) forx =%r", x))
         for n in xrange(2*SHIFT):
-            p2 = 2L ** n
+            p2 = 2 ** n
             eq(x << n >> n, x,
                 Frm("x << n >> n != x for x=%r, n=%r", (x, n)))
             eq(x // p2, x >> n,
@@ -217,7 +217,7 @@
             msg = Frm("%s returned %r but expected %r for %r",
                 mapper.__name__, got, expected, x)
             self.assertEqual(got, expected, msg)
-            self.assertEqual(long(got, 0), x, Frm('long("%s", 0) != %r', got, x))
+            self.assertEqual(int(got, 0), x, Frm('long("%s", 0) != %r', got, x))
         # str() has to be checked a little differently since there's no
         # trailing "L"
         got = str(x)
@@ -240,8 +240,8 @@
         # check the extremes in int<->long conversion
         hugepos = sys.maxint
         hugeneg = -hugepos - 1
-        hugepos_aslong = long(hugepos)
-        hugeneg_aslong = long(hugeneg)
+        hugepos_aslong = int(hugepos)
+        hugeneg_aslong = int(hugeneg)
         self.assertEqual(hugepos, hugepos_aslong, "long(sys.maxint) != sys.maxint")
         self.assertEqual(hugeneg, hugeneg_aslong,
             "long(-sys.maxint-1) != -sys.maxint-1")
@@ -270,7 +270,7 @@
             y = int(x)
         except OverflowError:
             self.fail("int(long(sys.maxint) + 1) mustn't overflow")
-        self.assert_(isinstance(y, long),
+        self.assert_(isinstance(y, int),
             "int(long(sys.maxint) + 1) should have returned long")
 
         x = hugeneg_aslong - 1
@@ -278,14 +278,14 @@
             y = int(x)
         except OverflowError:
             self.fail("int(long(-sys.maxint-1) - 1) mustn't overflow")
-        self.assert_(isinstance(y, long),
+        self.assert_(isinstance(y, int),
                "int(long(-sys.maxint-1) - 1) should have returned long")
 
-        class long2(long):
+        class long2(int):
             pass
-        x = long2(1L<<100)
+        x = long2(1<<100)
         y = int(x)
-        self.assert_(type(y) is long,
+        self.assert_(type(y) is int,
             "overflowing int conversion must return long not long subtype")
 
         # long -> Py_ssize_t conversion
@@ -293,10 +293,10 @@
             def __getslice__(self, i, j):
                 return i, j
 
-        self.assertEqual(X()[-5L:7L], (-5, 7))
+        self.assertEqual(X()[-5:7], (-5, 7))
         # use the clamping effect to test the smallest and largest longs
         # that fit a Py_ssize_t
-        slicemin, slicemax = X()[-2L**100:2L**100]
+        slicemin, slicemax = X()[-2**100:2**100]
         self.assertEqual(X()[slicemin:slicemax], (slicemin, slicemax))
 
 # ----------------------------------- tests of auto int->long conversion
@@ -315,14 +315,14 @@
                 Frm("for %r expected %r got %r", args, expected, got))
 
         for x in special:
-            longx = long(x)
+            longx = int(x)
 
             expected = -longx
             got = -x
             checkit('-', x)
 
             for y in special:
-                longy = long(y)
+                longy = int(y)
 
                 expected = longx + longy
                 got = x + y
@@ -357,20 +357,20 @@
                     for z in special:
                         if z != 0 :
                             if y >= 0:
-                                expected = pow(longx, longy, long(z))
+                                expected = pow(longx, longy, int(z))
                                 got = pow(x, y, z)
                                 checkit('pow', x, y, '%', z)
                             else:
-                                self.assertRaises(TypeError, pow,longx, longy, long(z))
+                                self.assertRaises(TypeError, pow,longx, longy, int(z))
 
     def test_float_overflow(self):
         import math
 
         for x in -2.0, -1.0, 0.0, 1.0, 2.0:
-            self.assertEqual(float(long(x)), x)
+            self.assertEqual(float(int(x)), x)
 
         shuge = '12345' * 120
-        huge = 1L << 30000
+        huge = 1 << 30000
         mhuge = -huge
         namespace = {'huge': huge, 'mhuge': mhuge, 'shuge': shuge, 'math': math}
         for test in ["float(huge)", "float(mhuge)",
@@ -410,7 +410,7 @@
             log = math.log(value)
             self.assertAlmostEqual(log, expected)
 
-        for bad in -(1L << 10000), -2L, 0L:
+        for bad in -(1 << 10000), -2, 0:
             self.assertRaises(ValueError, math.log, bad)
             self.assertRaises(ValueError, math.log10, bad)
 
@@ -426,7 +426,7 @@
         # represents all Python ints, longs and floats exactly).
         class Rat:
             def __init__(self, value):
-                if isinstance(value, (int, long)):
+                if isinstance(value, (int, int)):
                     self.n = value
                     self.d = 1
                 elif isinstance(value, float):
@@ -475,12 +475,12 @@
         # important boundary for IEEE double precision.
         for t in 2.0**48, 2.0**50, 2.0**53:
             cases.extend([t - 1.0, t - 0.3, t, t + 0.3, t + 1.0,
-                          long(t-1), long(t), long(t+1)])
+                          int(t-1), int(t), int(t+1)])
         cases.extend([0, 1, 2, sys.maxint, float(sys.maxint)])
         # 1L<<20000 should exceed all double formats.  long(1e200) is to
         # check that we get equality with 1e200 above.
-        t = long(1e200)
-        cases.extend([0L, 1L, 2L, 1L << 20000, t-1, t, t+1])
+        t = int(1e200)
+        cases.extend([0, 1, 2, 1 << 20000, t-1, t, t+1])
         cases.extend([-x for x in cases])
         for x in cases:
             Rx = Rat(x)
diff --git a/Lib/test/test_long_future.py b/Lib/test/test_long_future.py
index 074c148..3f137d6 100644
--- a/Lib/test/test_long_future.py
+++ b/Lib/test/test_long_future.py
@@ -8,16 +8,16 @@
 def test_true_division():
     if verbose:
         print "long true division"
-    huge = 1L << 40000
+    huge = 1 << 40000
     mhuge = -huge
     verify(huge / huge == 1.0)
     verify(mhuge / mhuge == 1.0)
     verify(huge / mhuge == -1.0)
     verify(mhuge / huge == -1.0)
     verify(1 / huge == 0.0)
-    verify(1L / huge == 0.0)
+    verify(1 / huge == 0.0)
     verify(1 / mhuge == 0.0)
-    verify(1L / mhuge == 0.0)
+    verify(1 / mhuge == 0.0)
     verify((666 * huge + (huge >> 1)) / huge == 666.5)
     verify((666 * mhuge + (mhuge >> 1)) / mhuge == 666.5)
     verify((666 * huge + (huge >> 1)) / mhuge == -666.5)
@@ -28,8 +28,8 @@
     namespace = {'huge': huge, 'mhuge': mhuge}
 
     for overflow in ["float(huge)", "float(mhuge)",
-                     "huge / 1", "huge / 2L", "huge / -1", "huge / -2L",
-                     "mhuge / 100", "mhuge / 100L"]:
+                     "huge / 1", "huge / 2", "huge / -1", "huge / -2",
+                     "mhuge / 100", "mhuge / 100"]:
         try:
             eval(overflow, namespace)
         except OverflowError:
@@ -37,14 +37,14 @@
         else:
             raise TestFailed("expected OverflowError from %r" % overflow)
 
-    for underflow in ["1 / huge", "2L / huge", "-1 / huge", "-2L / huge",
-                     "100 / mhuge", "100L / mhuge"]:
+    for underflow in ["1 / huge", "2 / huge", "-1 / huge", "-2 / huge",
+                     "100 / mhuge", "100 / mhuge"]:
         result = eval(underflow, namespace)
         if result != 0.0:
             raise TestFailed("expected underflow to 0 from %r" % underflow)
 
-    for zero in ["huge / 0", "huge / 0L",
-                 "mhuge / 0", "mhuge / 0L"]:
+    for zero in ["huge / 0", "huge / 0",
+                 "mhuge / 0", "mhuge / 0"]:
         try:
             eval(zero, namespace)
         except ZeroDivisionError:
diff --git a/Lib/test/test_marshal.py b/Lib/test/test_marshal.py
index fa1f688..bcd2918 100644
--- a/Lib/test/test_marshal.py
+++ b/Lib/test/test_marshal.py
@@ -33,7 +33,7 @@
                 value >>= 8
             return ''.join(bytes)
 
-        maxint64 = (1L << 63) - 1
+        maxint64 = (1 << 63) - 1
         minint64 = -maxint64-1
 
         for base in maxint64, minint64, -maxint64, -(minint64 >> 1):
@@ -152,7 +152,7 @@
     d = {'astring': 'foo@bar.baz.spam',
          'afloat': 7283.43,
          'anint': 2**20,
-         'ashortlong': 2L,
+         'ashortlong': 2,
          'alist': ['.zyx.41'],
          'atuple': ('.zyx.41',)*10,
          'aboolean': False,
@@ -204,7 +204,7 @@
     def test_patch_873224(self):
         self.assertRaises(Exception, marshal.loads, '0')
         self.assertRaises(Exception, marshal.loads, 'f')
-        self.assertRaises(Exception, marshal.loads, marshal.dumps(2**65L)[:-1])
+        self.assertRaises(Exception, marshal.loads, marshal.dumps(2**65)[:-1])
 
     def test_version_argument(self):
         # Python 2.4.0 crashes for any call to marshal.dumps(x, y)
diff --git a/Lib/test/test_multibytecodec_support.py b/Lib/test/test_multibytecodec_support.py
index 50ed481..d94d115 100644
--- a/Lib/test/test_multibytecodec_support.py
+++ b/Lib/test/test_multibytecodec_support.py
@@ -98,7 +98,7 @@
 
     def test_callback_long_index(self):
         def myreplace(exc):
-            return (u'x', long(exc.end))
+            return (u'x', int(exc.end))
         codecs.register_error("test.cjktest", myreplace)
         self.assertEqual(self.encode(u'abcd' + self.unmappedunicode + u'efgh',
                                      'test.cjktest'), ('abcdxefgh', 9))
diff --git a/Lib/test/test_operator.py b/Lib/test/test_operator.py
index 152d5ec..c71a4e6 100644
--- a/Lib/test/test_operator.py
+++ b/Lib/test/test_operator.py
@@ -199,7 +199,7 @@
         self.failUnlessRaises(TypeError, operator.isNumberType)
         self.failUnless(operator.isNumberType(8))
         self.failUnless(operator.isNumberType(8j))
-        self.failUnless(operator.isNumberType(8L))
+        self.failUnless(operator.isNumberType(8))
         self.failUnless(operator.isNumberType(8.3))
         self.failIf(operator.isNumberType(dir()))
 
diff --git a/Lib/test/test_optparse.py b/Lib/test/test_optparse.py
index e05fbc6..6ec2902 100644
--- a/Lib/test/test_optparse.py
+++ b/Lib/test/test_optparse.py
@@ -1598,7 +1598,7 @@
     def setUp(self):
         self.parser = InterceptingOptionParser()
         self.parser.add_option("-n", type=int)
-        self.parser.add_option("-l", type=long)
+        self.parser.add_option("-l", type=int)
 
     def test_parse_num_fail(self):
         self.assertRaises(
@@ -1606,17 +1606,17 @@
             ValueError,
             re.compile(r"invalid literal for int().*: '?'?"))
         self.assertRaises(
-            _parse_num, ("0xOoops", long), {},
+            _parse_num, ("0xOoops", int), {},
             ValueError,
             re.compile(r"invalid literal for int().*: '?0xOoops'?"))
 
     def test_parse_num_ok(self):
         self.assertEqual(_parse_num("0", int), 0)
         self.assertEqual(_parse_num("0x10", int), 16)
-        self.assertEqual(_parse_num("0XA", long), 10L)
-        self.assertEqual(_parse_num("010", long), 8L)
+        self.assertEqual(_parse_num("0XA", int), 10)
+        self.assertEqual(_parse_num("010", int), 8)
         self.assertEqual(_parse_num("0b11", int), 3)
-        self.assertEqual(_parse_num("0b", long), 0L)
+        self.assertEqual(_parse_num("0b", int), 0)
 
     def test_numeric_options(self):
         self.assertParseOK(["-n", "42", "-l", "0x20"],
diff --git a/Lib/test/test_poll.py b/Lib/test/test_poll.py
index 60cd3f4..6fbe1b6 100644
--- a/Lib/test/test_poll.py
+++ b/Lib/test/test_poll.py
@@ -143,7 +143,7 @@
         pollster = select.poll()
         pollster.register(1)
 
-        self.assertRaises(OverflowError, pollster.poll, 1L << 64)
+        self.assertRaises(OverflowError, pollster.poll, 1 << 64)
 
         x = 2 + 3
         if x != 5:
diff --git a/Lib/test/test_pow.py b/Lib/test/test_pow.py
index c6ab218..493aac2 100644
--- a/Lib/test/test_pow.py
+++ b/Lib/test/test_pow.py
@@ -18,14 +18,14 @@
                 self.assertEquals(pow(2, i), pow2)
                 if i != 30 : pow2 = pow2*2
 
-            for othertype in int, long:
+            for othertype in int, int:
                 for i in range(-10, 0) + range(1, 10):
                     ii = type(i)
                     for j in range(1, 11):
                         jj = -othertype(j)
                         pow(ii, jj)
 
-        for othertype in int, long, float:
+        for othertype in int, int, float:
             for i in range(1, 100):
                 zero = type(0)
                 exp = -othertype(i/10.0)
@@ -42,7 +42,7 @@
             asseq = self.assertAlmostEqual
         elif type == int:
             jl = 0
-        elif type == long:
+        elif type == int:
             jl, jh = 0, 15
         for i in range(il, ih+1):
             for j in range(jl, jh+1):
@@ -60,7 +60,7 @@
         self.powtest(int)
 
     def test_powlong(self):
-        self.powtest(long)
+        self.powtest(int)
 
     def test_powfloat(self):
         self.powtest(float)
@@ -74,12 +74,12 @@
         self.assertEquals(pow(-3,3) % -8, pow(-3,3,-8))
         self.assertEquals(pow(5,2) % -8, pow(5,2,-8))
 
-        self.assertEquals(pow(3L,3L) % 8, pow(3L,3L,8))
-        self.assertEquals(pow(3L,3L) % -8, pow(3L,3L,-8))
-        self.assertEquals(pow(3L,2) % -2, pow(3L,2,-2))
-        self.assertEquals(pow(-3L,3L) % 8, pow(-3L,3L,8))
-        self.assertEquals(pow(-3L,3L) % -8, pow(-3L,3L,-8))
-        self.assertEquals(pow(5L,2) % -8, pow(5L,2,-8))
+        self.assertEquals(pow(3,3) % 8, pow(3,3,8))
+        self.assertEquals(pow(3,3) % -8, pow(3,3,-8))
+        self.assertEquals(pow(3,2) % -2, pow(3,2,-2))
+        self.assertEquals(pow(-3,3) % 8, pow(-3,3,8))
+        self.assertEquals(pow(-3,3) % -8, pow(-3,3,-8))
+        self.assertEquals(pow(5,2) % -8, pow(5,2,-8))
 
         for i in range(-10, 11):
             for j in range(0, 6):
@@ -91,8 +91,8 @@
                         )
                     if j >= 0 and k != 0:
                         self.assertEquals(
-                            pow(long(i),j) % k,
-                            pow(long(i),j,k)
+                            pow(int(i),j) % k,
+                            pow(int(i),j,k)
                         )
 
     def test_bug643260(self):
diff --git a/Lib/test/test_pprint.py b/Lib/test/test_pprint.py
index 09ba268..8fc8d10 100644
--- a/Lib/test/test_pprint.py
+++ b/Lib/test/test_pprint.py
@@ -114,12 +114,12 @@
         # multiple lines.  For that reason, dicts with more than one element
         # aren't tested here.
         verify = self.assert_
-        for simple in (0, 0L, 0+0j, 0.0, "", uni(""),
+        for simple in (0, 0, 0+0j, 0.0, "", uni(""),
                        (), tuple2(), tuple3(),
                        [], list2(), list3(),
                        {}, dict2(), dict3(),
                        verify, pprint,
-                       -6, -6L, -6-6j, -1.5, "x", uni("x"), (3,), [3], {3: 6},
+                       -6, -6, -6-6j, -1.5, "x", uni("x"), (3,), [3], {3: 6},
                        (1,2), [3,4], {5: 6, 7: 8},
                        tuple2((1,2)), tuple3((1,2)), tuple3(range(100)),
                        [3,4], list2([3,4]), list3([3,4]), list3(range(100)),
diff --git a/Lib/test/test_random.py b/Lib/test/test_random.py
index 7ec130d..0e0a273 100644
--- a/Lib/test/test_random.py
+++ b/Lib/test/test_random.py
@@ -34,7 +34,7 @@
         self.assertEqual(randseq, self.randomlist(N))
 
     def test_seedargs(self):
-        for arg in [None, 0, 0L, 1, 1L, -1, -1L, 10**20, -(10**20),
+        for arg in [None, 0, 0, 1, 1, -1, -1, 10**20, -(10**20),
                     3.14, 1+2j, 'a', tuple('abc')]:
             self.gen.seed(arg)
         for arg in [range(3), dict(one=1)]:
@@ -268,7 +268,7 @@
         # show that: k = int(1.001 + _log(n, 2))
         # is equal to or one greater than the number of bits in n
         for i in xrange(1, 1000):
-            n = 1L << i # check an exact power of two
+            n = 1 << i # check an exact power of two
             numbits = i+1
             k = int(1.00001 + _log(n, 2))
             self.assertEqual(k, numbits)
@@ -327,7 +327,7 @@
                     0.089215024911993401,
                     0.78486196105372907]
 
-        self.gen.seed(61731L + (24903L<<32) + (614L<<64) + (42143L<<96))
+        self.gen.seed(61731 + (24903<<32) + (614<<64) + (42143<<96))
         actual = self.randomlist(2000)[-10:]
         for a, e in zip(actual, expected):
             self.assertAlmostEqual(a,e,places=14)
@@ -339,20 +339,20 @@
         # no rounding errors -- all results are exact).
         from math import ldexp
 
-        expected = [0x0eab3258d2231fL,
-                    0x1b89db315277a5L,
-                    0x1db622a5518016L,
-                    0x0b7f9af0d575bfL,
-                    0x029e4c4db82240L,
-                    0x04961892f5d673L,
-                    0x02b291598e4589L,
-                    0x11388382c15694L,
-                    0x02dad977c9e1feL,
-                    0x191d96d4d334c6L]
-        self.gen.seed(61731L + (24903L<<32) + (614L<<64) + (42143L<<96))
+        expected = [0x0eab3258d2231f,
+                    0x1b89db315277a5,
+                    0x1db622a5518016,
+                    0x0b7f9af0d575bf,
+                    0x029e4c4db82240,
+                    0x04961892f5d673,
+                    0x02b291598e4589,
+                    0x11388382c15694,
+                    0x02dad977c9e1fe,
+                    0x191d96d4d334c6]
+        self.gen.seed(61731 + (24903<<32) + (614<<64) + (42143<<96))
         actual = self.randomlist(2000)[-10:]
         for a, e in zip(actual, expected):
-            self.assertEqual(long(ldexp(a, 53)), e)
+            self.assertEqual(int(ldexp(a, 53)), e)
 
     def test_long_seed(self):
         # This is most interesting to run in debug mode, just to make sure
@@ -360,7 +360,7 @@
         # is allocated, consuming space proportional to the number of bits
         # in the seed.  Unfortunately, that's a quadratic-time algorithm,
         # so don't make this horribly big.
-        seed = (1L << (10000 * 8)) - 1  # about 10K bytes
+        seed = (1 << (10000 * 8)) - 1  # about 10K bytes
         self.gen.seed(seed)
 
     def test_53_bits_per_float(self):
@@ -399,7 +399,7 @@
         # Verify cross-platform repeatability
         self.gen.seed(1234567)
         self.assertEqual(self.gen.getrandbits(100),
-                         97904845777343510404718956115L)
+                         97904845777343510404718956115)
         # Verify ranges
         for k in xrange(1, 1000):
             self.assert_(0 <= self.gen.getrandbits(k) < 2**k)
@@ -424,7 +424,7 @@
         # show that: k = int(1.001 + _log(n, 2))
         # is equal to or one greater than the number of bits in n
         for i in xrange(1, 1000):
-            n = 1L << i # check an exact power of two
+            n = 1 << i # check an exact power of two
             numbits = i+1
             k = int(1.00001 + _log(n, 2))
             self.assertEqual(k, numbits)
diff --git a/Lib/test/test_repr.py b/Lib/test/test_repr.py
index 823298b..1435c6f 100644
--- a/Lib/test/test_repr.py
+++ b/Lib/test/test_repr.py
@@ -90,10 +90,10 @@
     def test_numbers(self):
         eq = self.assertEquals
         eq(r(123), repr(123))
-        eq(r(123L), repr(123L))
+        eq(r(123), repr(123))
         eq(r(1.0/3), repr(1.0/3))
 
-        n = 10L**100
+        n = 10**100
         expected = repr(n)[:18] + "..." + repr(n)[-19:]
         eq(r(n), expected)
 
diff --git a/Lib/test/test_resource.py b/Lib/test/test_resource.py
index 29ce35b..31aa370 100644
--- a/Lib/test/test_resource.py
+++ b/Lib/test/test_resource.py
@@ -45,7 +45,7 @@
     resource.setrlimit(resource.RLIMIT_FSIZE, (cur, max))
 
 # And be sure that setrlimit is checking for really large values
-too_big = 10L**50
+too_big = 10**50
 try:
     resource.setrlimit(resource.RLIMIT_FSIZE, (too_big, max))
 except (OverflowError, ValueError):
diff --git a/Lib/test/test_slice.py b/Lib/test/test_slice.py
index bd6e621..f22f619 100644
--- a/Lib/test/test_slice.py
+++ b/Lib/test/test_slice.py
@@ -86,11 +86,11 @@
             slice(100,  -100,  -1).indices(10),
             slice(None, None, -1).indices(10)
         )
-        self.assertEqual(slice(-100L, 100L, 2L).indices(10), (0, 10,  2))
+        self.assertEqual(slice(-100, 100, 2).indices(10), (0, 10,  2))
 
         self.assertEqual(range(10)[::sys.maxint - 1], [0])
 
-        self.assertRaises(OverflowError, slice(None).indices, 1L<<100)
+        self.assertRaises(OverflowError, slice(None).indices, 1<<100)
 
 def test_main():
     test_support.run_unittest(SliceTest)
diff --git a/Lib/test/test_socket.py b/Lib/test/test_socket.py
index ecfb1ed..1f26b4e 100644
--- a/Lib/test/test_socket.py
+++ b/Lib/test/test_socket.py
@@ -302,17 +302,17 @@
         sizes = {socket.htonl: 32, socket.ntohl: 32,
                  socket.htons: 16, socket.ntohs: 16}
         for func, size in sizes.items():
-            mask = (1L<<size) - 1
+            mask = (1<<size) - 1
             for i in (0, 1, 0xffff, ~0xffff, 2, 0x01234567, 0x76543210):
                 self.assertEqual(i & mask, func(func(i&mask)) & mask)
 
             swapped = func(mask)
             self.assertEqual(swapped & mask, mask)
-            self.assertRaises(OverflowError, func, 1L<<34)
+            self.assertRaises(OverflowError, func, 1<<34)
 
     def testNtoHErrors(self):
-        good_values = [ 1, 2, 3, 1L, 2L, 3L ]
-        bad_values = [ -1, -2, -3, -1L, -2L, -3L ]
+        good_values = [ 1, 2, 3, 1, 2, 3 ]
+        bad_values = [ -1, -2, -3, -1, -2, -3 ]
         for k in good_values:
             socket.ntohl(k)
             socket.ntohs(k)
diff --git a/Lib/test/test_strftime.py b/Lib/test/test_strftime.py
index 00fa227..26bae1b 100755
--- a/Lib/test/test_strftime.py
+++ b/Lib/test/test_strftime.py
@@ -41,7 +41,7 @@
 def strftest(now):
     if verbose:
         print "strftime test for", time.ctime(now)
-    nowsecs = str(long(now))[:-1]
+    nowsecs = str(int(now))[:-1]
     gmt = time.gmtime(now)
     now = time.localtime(now)
 
diff --git a/Lib/test/test_string.py b/Lib/test/test_string.py
index 6d5e8e4..6e9c122 100644
--- a/Lib/test/test_string.py
+++ b/Lib/test/test_string.py
@@ -83,7 +83,7 @@
         self.assertRaises(ValueError, string.atoi, " x1 ")
 
     def test_atol(self):
-        self.assertEqual(string.atol("  1  "), 1L)
+        self.assertEqual(string.atol("  1  "), 1)
         self.assertRaises(ValueError, string.atol, "  1x ")
         self.assertRaises(ValueError, string.atol, "  x1 ")
 
diff --git a/Lib/test/test_strop.py b/Lib/test/test_strop.py
index 2ac7986..66e7eb6 100644
--- a/Lib/test/test_strop.py
+++ b/Lib/test/test_strop.py
@@ -15,7 +15,7 @@
         self.assertRaises(ValueError, strop.atoi, " x1 ")
 
     def test_atol(self):
-        self.assert_(strop.atol(" 1 ") == 1L)
+        self.assert_(strop.atol(" 1 ") == 1)
         self.assertRaises(ValueError, strop.atol, " 1x")
         self.assertRaises(ValueError, strop.atol, " x1 ")
 
diff --git a/Lib/test/test_struct.py b/Lib/test/test_struct.py
index d4744dd..f1bef4b 100644
--- a/Lib/test/test_struct.py
+++ b/Lib/test/test_struct.py
@@ -146,12 +146,12 @@
     ('H', 0x10000-700, '\375D', 'D\375', 0),
     ('i', 70000000, '\004,\035\200', '\200\035,\004', 0),
     ('i', -70000000, '\373\323\342\200', '\200\342\323\373', 0),
-    ('I', 70000000L, '\004,\035\200', '\200\035,\004', 0),
-    ('I', 0x100000000L-70000000, '\373\323\342\200', '\200\342\323\373', 0),
+    ('I', 70000000, '\004,\035\200', '\200\035,\004', 0),
+    ('I', 0x100000000-70000000, '\373\323\342\200', '\200\342\323\373', 0),
     ('l', 70000000, '\004,\035\200', '\200\035,\004', 0),
     ('l', -70000000, '\373\323\342\200', '\200\342\323\373', 0),
-    ('L', 70000000L, '\004,\035\200', '\200\035,\004', 0),
-    ('L', 0x100000000L-70000000, '\373\323\342\200', '\200\342\323\373', 0),
+    ('L', 70000000, '\004,\035\200', '\200\035,\004', 0),
+    ('L', 0x100000000-70000000, '\373\323\342\200', '\200\342\323\373', 0),
     ('f', 2.0, '@\000\000\000', '\000\000\000@', 0),
     ('d', 2.0, '@\000\000\000\000\000\000\000',
                '\000\000\000\000\000\000\000@', 0),
@@ -203,9 +203,9 @@
             ('q', -1, '\xff' * bytes),
             ('q', 0, '\x00' * bytes),
             ('Q', 0, '\x00' * bytes),
-            ('q', 1L, '\x00' * (bytes-1) + '\x01'),
-            ('Q', (1L << (8*bytes))-1, '\xff' * bytes),
-            ('q', (1L << (8*bytes-1))-1, '\x7f' + '\xff' * (bytes - 1))):
+            ('q', 1, '\x00' * (bytes-1) + '\x01'),
+            ('Q', (1 << (8*bytes))-1, '\xff' * bytes),
+            ('q', (1 << (8*bytes-1))-1, '\x7f' + '\xff' * (bytes - 1))):
         got = struct.pack(format, input)
         native_expected = bigendian_to_native(expected)
         verify(got == native_expected,
@@ -243,9 +243,9 @@
         self.bitsize = bytesize * 8
         self.signed_code, self.unsigned_code = formatpair
         self.unsigned_min = 0
-        self.unsigned_max = 2L**self.bitsize - 1
-        self.signed_min = -(2L**(self.bitsize-1))
-        self.signed_max = 2L**(self.bitsize-1) - 1
+        self.unsigned_max = 2**self.bitsize - 1
+        self.signed_min = -(2**(self.bitsize-1))
+        self.signed_max = 2**(self.bitsize-1) - 1
 
     def test_one(self, x, pack=struct.pack,
                           unpack=struct.unpack,
@@ -257,9 +257,9 @@
         code = self.signed_code
         if self.signed_min <= x <= self.signed_max:
             # Try big-endian.
-            expected = long(x)
+            expected = int(x)
             if x < 0:
-                expected += 1L << self.bitsize
+                expected += 1 << self.bitsize
                 assert expected > 0
             expected = hex(expected)[2:] # chop "0x"
             if len(expected) & 1:
@@ -316,7 +316,7 @@
         if self.unsigned_min <= x <= self.unsigned_max:
             # Try big-endian.
             format = ">" + code
-            expected = long(x)
+            expected = int(x)
             expected = hex(expected)[2:] # chop "0x"
             if len(expected) & 1:
                 expected = "0" + expected
@@ -372,11 +372,11 @@
         # Create all interesting powers of 2.
         values = []
         for exp in range(self.bitsize + 3):
-            values.append(1L << exp)
+            values.append(1 << exp)
 
         # Add some random values.
         for i in range(self.bitsize):
-            val = 0L
+            val = 0
             for j in range(self.bytesize):
                 val = (val << 8) | randrange(256)
             values.append(val)
@@ -485,15 +485,15 @@
 def test_1229380():
     import sys
     for endian in ('', '>', '<'):
-        for cls in (int, long):
+        for cls in (int, int):
             for fmt in ('B', 'H', 'I', 'L'):
                 deprecated_err(struct.pack, endian + fmt, cls(-1))
 
             deprecated_err(struct.pack, endian + 'B', cls(300))
             deprecated_err(struct.pack, endian + 'H', cls(70000))
 
-        deprecated_err(struct.pack, endian + 'I', sys.maxint * 4L)
-        deprecated_err(struct.pack, endian + 'L', sys.maxint * 4L)
+        deprecated_err(struct.pack, endian + 'I', sys.maxint * 4)
+        deprecated_err(struct.pack, endian + 'L', sys.maxint * 4)
 
 if PY_STRUCT_RANGE_CHECKING:
     test_1229380()
diff --git a/Lib/test/test_time.py b/Lib/test/test_time.py
index 18129da..3a7fa0f 100644
--- a/Lib/test/test_time.py
+++ b/Lib/test/test_time.py
@@ -20,8 +20,8 @@
     def test_conversions(self):
         self.assert_(time.ctime(self.t)
                      == time.asctime(time.localtime(self.t)))
-        self.assert_(long(time.mktime(time.localtime(self.t)))
-                     == long(self.t))
+        self.assert_(int(time.mktime(time.localtime(self.t)))
+                     == int(self.t))
 
     def test_sleep(self):
         time.sleep(1.2)
diff --git a/Lib/test/test_timeout.py b/Lib/test/test_timeout.py
index 2b32b92..94765d9 100644
--- a/Lib/test/test_timeout.py
+++ b/Lib/test/test_timeout.py
@@ -46,7 +46,7 @@
     def testTypeCheck(self):
         # Test type checking by settimeout()
         self.sock.settimeout(0)
-        self.sock.settimeout(0L)
+        self.sock.settimeout(0)
         self.sock.settimeout(0.0)
         self.sock.settimeout(None)
         self.assertRaises(TypeError, self.sock.settimeout, "")
@@ -59,7 +59,7 @@
     def testRangeCheck(self):
         # Test range checking by settimeout()
         self.assertRaises(ValueError, self.sock.settimeout, -1)
-        self.assertRaises(ValueError, self.sock.settimeout, -1L)
+        self.assertRaises(ValueError, self.sock.settimeout, -1)
         self.assertRaises(ValueError, self.sock.settimeout, -1.0)
 
     def testTimeoutThenBlocking(self):
diff --git a/Lib/test/test_types.py b/Lib/test/test_types.py
index 8d26914..f5970ba 100644
--- a/Lib/test/test_types.py
+++ b/Lib/test/test_types.py
@@ -9,11 +9,11 @@
     def test_truth_values(self):
         if None: self.fail('None is true instead of false')
         if 0: self.fail('0 is true instead of false')
-        if 0L: self.fail('0L is true instead of false')
+        if 0: self.fail('0L is true instead of false')
         if 0.0: self.fail('0.0 is true instead of false')
         if '': self.fail('\'\' is true instead of false')
         if not 1: self.fail('1 is false instead of true')
-        if not 1L: self.fail('1L is false instead of true')
+        if not 1: self.fail('1L is false instead of true')
         if not 1.0: self.fail('1.0 is false instead of true')
         if not 'x': self.fail('\'x\' is false instead of true')
         if not {'x': 1}: self.fail('{\'x\': 1} is false instead of true')
@@ -35,7 +35,7 @@
     def test_comparisons(self):
         if 0 < 1 <= 1 == 1 >= 1 > 0 != 1: pass
         else: self.fail('int comparisons failed')
-        if 0L < 1L <= 1L == 1L >= 1L > 0L != 1L: pass
+        if 0 < 1 <= 1 == 1 >= 1 > 0 != 1: pass
         else: self.fail('long int comparisons failed')
         if 0.0 < 1.0 <= 1.0 == 1.0 >= 1.0 > 0.0 != 1.0: pass
         else: self.fail('float comparisons failed')
@@ -61,30 +61,30 @@
         except ZeroDivisionError: pass
         else: self.fail("5.0 % 0.0 didn't raise ZeroDivisionError")
 
-        try: 5 / 0L
+        try: 5 / 0
         except ZeroDivisionError: pass
         else: self.fail("5 / 0L didn't raise ZeroDivisionError")
 
-        try: 5 // 0L
+        try: 5 // 0
         except ZeroDivisionError: pass
         else: self.fail("5 // 0L didn't raise ZeroDivisionError")
 
-        try: 5 % 0L
+        try: 5 % 0
         except ZeroDivisionError: pass
         else: self.fail("5 % 0L didn't raise ZeroDivisionError")
 
     def test_numeric_types(self):
-        if 0 != 0L or 0 != 0.0 or 0L != 0.0: self.fail('mixed comparisons')
-        if 1 != 1L or 1 != 1.0 or 1L != 1.0: self.fail('mixed comparisons')
-        if -1 != -1L or -1 != -1.0 or -1L != -1.0:
+        if 0 != 0 or 0 != 0.0 or 0 != 0.0: self.fail('mixed comparisons')
+        if 1 != 1 or 1 != 1.0 or 1 != 1.0: self.fail('mixed comparisons')
+        if -1 != -1 or -1 != -1.0 or -1 != -1.0:
             self.fail('int/long/float value not equal')
         # calling built-in types without argument must return 0
         if int() != 0: self.fail('int() does not return 0')
-        if long() != 0L: self.fail('long() does not return 0L')
+        if int() != 0: self.fail('long() does not return 0L')
         if float() != 0.0: self.fail('float() does not return 0.0')
         if int(1.9) == 1 == int(1.1) and int(-1.1) == -1 == int(-1.9): pass
         else: self.fail('int() does not round properly')
-        if long(1.9) == 1L == long(1.1) and long(-1.1) == -1L == long(-1.9): pass
+        if int(1.9) == 1 == int(1.1) and int(-1.1) == -1 == int(-1.9): pass
         else: self.fail('long() does not round properly')
         if float(1) == 1.0 and float(-1) == -1.0 and float(0) == 0.0: pass
         else: self.fail('float() does not work properly')
@@ -118,7 +118,7 @@
         for divisor in 1, 2, 4, 8, 16, 32:
             j = m // divisor - 1
             prod = divisor * j
-            if type(prod) is not long:
+            if type(prod) is not int:
                 self.fail("expected type(%r) to be long, not %r" %
                                    (prod, type(prod)))
         # Check for expected * overflow to long.
@@ -126,35 +126,35 @@
         for divisor in 1, 2, 4, 8, 16, 32:
             j = m // divisor + 1
             prod = divisor * j
-            if type(prod) is not long:
+            if type(prod) is not int:
                 self.fail("expected type(%r) to be long, not %r" %
                                    (prod, type(prod)))
 
     def test_long_integers(self):
-        if 12L + 24L != 36L: self.fail('long op')
-        if 12L + (-24L) != -12L: self.fail('long op')
-        if (-12L) + 24L != 12L: self.fail('long op')
-        if (-12L) + (-24L) != -36L: self.fail('long op')
-        if not 12L < 24L: self.fail('long op')
-        if not -24L < -12L: self.fail('long op')
+        if 12 + 24 != 36: self.fail('long op')
+        if 12 + (-24) != -12: self.fail('long op')
+        if (-12) + 24 != 12: self.fail('long op')
+        if (-12) + (-24) != -36: self.fail('long op')
+        if not 12 < 24: self.fail('long op')
+        if not -24 < -12: self.fail('long op')
         x = sys.maxint
-        if int(long(x)) != x: self.fail('long op')
-        try: y = int(long(x)+1L)
+        if int(int(x)) != x: self.fail('long op')
+        try: y = int(int(x)+1)
         except OverflowError: self.fail('long op')
-        if not isinstance(y, long): self.fail('long op')
+        if not isinstance(y, int): self.fail('long op')
         x = -x
-        if int(long(x)) != x: self.fail('long op')
+        if int(int(x)) != x: self.fail('long op')
         x = x-1
-        if int(long(x)) != x: self.fail('long op')
-        try: y = int(long(x)-1L)
+        if int(int(x)) != x: self.fail('long op')
+        try: y = int(int(x)-1)
         except OverflowError: self.fail('long op')
-        if not isinstance(y, long): self.fail('long op')
+        if not isinstance(y, int): self.fail('long op')
 
         try: 5 << -5
         except ValueError: pass
         else: self.fail('int negative shift <<')
 
-        try: 5L << -5L
+        try: 5 << -5
         except ValueError: pass
         else: self.fail('long negative shift <<')
 
@@ -162,7 +162,7 @@
         except ValueError: pass
         else: self.fail('int negative shift >>')
 
-        try: 5L >> -5L
+        try: 5 >> -5
         except ValueError: pass
         else: self.fail('long negative shift >>')
 
@@ -197,7 +197,7 @@
         self.assertEqual(a[3::-2], '31')
         self.assertEqual(a[-100:100:], a)
         self.assertEqual(a[100:-100:-1], a[::-1])
-        self.assertEqual(a[-100L:100L:2L], '02468')
+        self.assertEqual(a[-100:100:2], '02468')
 
         if have_unicode:
             a = unicode('0123456789', 'ascii')
@@ -209,7 +209,7 @@
             self.assertEqual(a[3::-2], unicode('31', 'ascii'))
             self.assertEqual(a[-100:100:], a)
             self.assertEqual(a[100:-100:-1], a[::-1])
-            self.assertEqual(a[-100L:100L:2L], unicode('02468', 'ascii'))
+            self.assertEqual(a[-100:100:2], unicode('02468', 'ascii'))
 
 
     def test_type_function(self):
diff --git a/Lib/test/test_unary.py b/Lib/test/test_unary.py
index 9854f64..1e07c15 100644
--- a/Lib/test/test_unary.py
+++ b/Lib/test/test_unary.py
@@ -9,7 +9,7 @@
         self.assert_(-2 == 0 - 2)
         self.assert_(-0 == 0)
         self.assert_(--2 == 2)
-        self.assert_(-2L == 0 - 2L)
+        self.assert_(-2 == 0 - 2)
         self.assert_(-2.0 == 0 - 2.0)
         self.assert_(-2j == 0 - 2j)
 
@@ -17,7 +17,7 @@
         self.assert_(+2 == 2)
         self.assert_(+0 == 0)
         self.assert_(++2 == 2)
-        self.assert_(+2L == 2L)
+        self.assert_(+2 == 2)
         self.assert_(+2.0 == 2.0)
         self.assert_(+2j == 2j)
 
@@ -25,13 +25,13 @@
         self.assert_(-2 == 0 - 2)
         self.assert_(-0 == 0)
         self.assert_(--2 == 2)
-        self.assert_(-2L == 0 - 2L)
+        self.assert_(-2 == 0 - 2)
 
     def test_no_overflow(self):
         nines = "9" * 32
-        self.assert_(eval("+" + nines) == eval("+" + nines + "L"))
-        self.assert_(eval("-" + nines) == eval("-" + nines + "L"))
-        self.assert_(eval("~" + nines) == eval("~" + nines + "L"))
+        self.assert_(eval("+" + nines) == 10**32-1)
+        self.assert_(eval("-" + nines) == -(10**32-1))
+        self.assert_(eval("~" + nines) == ~(10**32-1))
 
     def test_negation_of_exponentiation(self):
         # Make sure '**' does the right thing; these form a
diff --git a/Lib/test/test_unicode.py b/Lib/test/test_unicode.py
index 38ff9ac..5c70df1 100644
--- a/Lib/test/test_unicode.py
+++ b/Lib/test/test_unicode.py
@@ -483,7 +483,7 @@
                          UnicodeCompat(u"u'%s' % obj falls back to obj.__str__()"),
                          u"u'%s' % obj falls back to obj.__str__()")
 
-        for obj in (123, 123.45, 123L):
+        for obj in (123, 123.45, 123):
             self.assertEqual(unicode(obj), unicode(str(obj)))
 
         # unicode(obj, encoding, error) tests (this maps to
diff --git a/Lib/test/test_uuid.py b/Lib/test/test_uuid.py
index 90671be..f1d1d1c 100644
--- a/Lib/test/test_uuid.py
+++ b/Lib/test/test_uuid.py
@@ -32,19 +32,19 @@
              '000102030405060708090a0b0c0d0e0f',
              '\0\x01\x02\x03\x04\x05\x06\x07\x08\t\n\x0b\x0c\x0d\x0e\x0f',
              '\x03\x02\x01\0\x05\x04\x07\x06\x08\t\n\x0b\x0c\x0d\x0e\x0f',
-             (0x00010203L, 0x0405, 0x0607, 8, 9, 0x0a0b0c0d0e0fL),
-             0x000102030405060708090a0b0c0d0e0fL,
+             (0x00010203, 0x0405, 0x0607, 8, 9, 0x0a0b0c0d0e0f),
+             0x000102030405060708090a0b0c0d0e0f,
              'urn:uuid:00010203-0405-0607-0809-0a0b0c0d0e0f',
-             0x607040500010203L, 0x809, uuid.RESERVED_NCS, None),
+             0x607040500010203, 0x809, uuid.RESERVED_NCS, None),
             ('02d9e6d5-9467-382e-8f9b-9300a64ac3cd',
              '{02d9e6d5-9467-382e-8f9b-9300a64ac3cd}',
              '02d9e6d59467382e8f9b9300a64ac3cd',
              '\x02\xd9\xe6\xd5\x94\x67\x38\x2e\x8f\x9b\x93\x00\xa6\x4a\xc3\xcd',
              '\xd5\xe6\xd9\x02\x67\x94\x2e\x38\x8f\x9b\x93\x00\xa6\x4a\xc3\xcd',
-             (0x02d9e6d5L, 0x9467, 0x382e, 0x8f, 0x9b, 0x9300a64ac3cdL),
-             0x02d9e6d59467382e8f9b9300a64ac3cdL,
+             (0x02d9e6d5, 0x9467, 0x382e, 0x8f, 0x9b, 0x9300a64ac3cd),
+             0x02d9e6d59467382e8f9b9300a64ac3cd,
              'urn:uuid:02d9e6d5-9467-382e-8f9b-9300a64ac3cd',
-             0x82e946702d9e6d5L, 0xf9b, uuid.RFC_4122, 3),
+             0x82e946702d9e6d5, 0xf9b, uuid.RFC_4122, 3),
             ('12345678-1234-5678-1234-567812345678',
              '{12345678-1234-5678-1234-567812345678}',
              '12345678123456781234567812345678',
@@ -53,97 +53,97 @@
              (0x12345678, 0x1234, 0x5678, 0x12, 0x34, 0x567812345678),
              0x12345678123456781234567812345678,
              'urn:uuid:12345678-1234-5678-1234-567812345678',
-             0x678123412345678L, 0x1234, uuid.RESERVED_NCS, None),
+             0x678123412345678, 0x1234, uuid.RESERVED_NCS, None),
             ('6ba7b810-9dad-11d1-80b4-00c04fd430c8',
              '{6ba7b810-9dad-11d1-80b4-00c04fd430c8}',
              '6ba7b8109dad11d180b400c04fd430c8',
              '\x6b\xa7\xb8\x10\x9d\xad\x11\xd1\x80\xb4\x00\xc0\x4f\xd4\x30\xc8',
              '\x10\xb8\xa7\x6b\xad\x9d\xd1\x11\x80\xb4\x00\xc0\x4f\xd4\x30\xc8',
-             (0x6ba7b810L, 0x9dad, 0x11d1, 0x80, 0xb4, 0x00c04fd430c8L),
-             0x6ba7b8109dad11d180b400c04fd430c8L,
+             (0x6ba7b810, 0x9dad, 0x11d1, 0x80, 0xb4, 0x00c04fd430c8),
+             0x6ba7b8109dad11d180b400c04fd430c8,
              'urn:uuid:6ba7b810-9dad-11d1-80b4-00c04fd430c8',
-             0x1d19dad6ba7b810L, 0xb4, uuid.RFC_4122, 1),
+             0x1d19dad6ba7b810, 0xb4, uuid.RFC_4122, 1),
             ('6ba7b811-9dad-11d1-80b4-00c04fd430c8',
              '{6ba7b811-9dad-11d1-80b4-00c04fd430c8}',
              '6ba7b8119dad11d180b400c04fd430c8',
              '\x6b\xa7\xb8\x11\x9d\xad\x11\xd1\x80\xb4\x00\xc0\x4f\xd4\x30\xc8',
              '\x11\xb8\xa7\x6b\xad\x9d\xd1\x11\x80\xb4\x00\xc0\x4f\xd4\x30\xc8',
-             (0x6ba7b811L, 0x9dad, 0x11d1, 0x80, 0xb4, 0x00c04fd430c8L),
-             0x6ba7b8119dad11d180b400c04fd430c8L,
+             (0x6ba7b811, 0x9dad, 0x11d1, 0x80, 0xb4, 0x00c04fd430c8),
+             0x6ba7b8119dad11d180b400c04fd430c8,
              'urn:uuid:6ba7b811-9dad-11d1-80b4-00c04fd430c8',
-             0x1d19dad6ba7b811L, 0xb4, uuid.RFC_4122, 1),
+             0x1d19dad6ba7b811, 0xb4, uuid.RFC_4122, 1),
             ('6ba7b812-9dad-11d1-80b4-00c04fd430c8',
              '{6ba7b812-9dad-11d1-80b4-00c04fd430c8}',
              '6ba7b8129dad11d180b400c04fd430c8',
              '\x6b\xa7\xb8\x12\x9d\xad\x11\xd1\x80\xb4\x00\xc0\x4f\xd4\x30\xc8',
              '\x12\xb8\xa7\x6b\xad\x9d\xd1\x11\x80\xb4\x00\xc0\x4f\xd4\x30\xc8',
-             (0x6ba7b812L, 0x9dad, 0x11d1, 0x80, 0xb4, 0x00c04fd430c8L),
-             0x6ba7b8129dad11d180b400c04fd430c8L,
+             (0x6ba7b812, 0x9dad, 0x11d1, 0x80, 0xb4, 0x00c04fd430c8),
+             0x6ba7b8129dad11d180b400c04fd430c8,
              'urn:uuid:6ba7b812-9dad-11d1-80b4-00c04fd430c8',
-             0x1d19dad6ba7b812L, 0xb4, uuid.RFC_4122, 1),
+             0x1d19dad6ba7b812, 0xb4, uuid.RFC_4122, 1),
             ('6ba7b814-9dad-11d1-80b4-00c04fd430c8',
              '{6ba7b814-9dad-11d1-80b4-00c04fd430c8}',
              '6ba7b8149dad11d180b400c04fd430c8',
              '\x6b\xa7\xb8\x14\x9d\xad\x11\xd1\x80\xb4\x00\xc0\x4f\xd4\x30\xc8',
              '\x14\xb8\xa7\x6b\xad\x9d\xd1\x11\x80\xb4\x00\xc0\x4f\xd4\x30\xc8',
-             (0x6ba7b814L, 0x9dad, 0x11d1, 0x80, 0xb4, 0x00c04fd430c8L),
-             0x6ba7b8149dad11d180b400c04fd430c8L,
+             (0x6ba7b814, 0x9dad, 0x11d1, 0x80, 0xb4, 0x00c04fd430c8),
+             0x6ba7b8149dad11d180b400c04fd430c8,
              'urn:uuid:6ba7b814-9dad-11d1-80b4-00c04fd430c8',
-             0x1d19dad6ba7b814L, 0xb4, uuid.RFC_4122, 1),
+             0x1d19dad6ba7b814, 0xb4, uuid.RFC_4122, 1),
             ('7d444840-9dc0-11d1-b245-5ffdce74fad2',
              '{7d444840-9dc0-11d1-b245-5ffdce74fad2}',
              '7d4448409dc011d1b2455ffdce74fad2',
              '\x7d\x44\x48\x40\x9d\xc0\x11\xd1\xb2\x45\x5f\xfd\xce\x74\xfa\xd2',
              '\x40\x48\x44\x7d\xc0\x9d\xd1\x11\xb2\x45\x5f\xfd\xce\x74\xfa\xd2',
-             (0x7d444840L, 0x9dc0, 0x11d1, 0xb2, 0x45, 0x5ffdce74fad2L),
-             0x7d4448409dc011d1b2455ffdce74fad2L,
+             (0x7d444840, 0x9dc0, 0x11d1, 0xb2, 0x45, 0x5ffdce74fad2),
+             0x7d4448409dc011d1b2455ffdce74fad2,
              'urn:uuid:7d444840-9dc0-11d1-b245-5ffdce74fad2',
-             0x1d19dc07d444840L, 0x3245, uuid.RFC_4122, 1),
+             0x1d19dc07d444840, 0x3245, uuid.RFC_4122, 1),
             ('e902893a-9d22-3c7e-a7b8-d6e313b71d9f',
              '{e902893a-9d22-3c7e-a7b8-d6e313b71d9f}',
              'e902893a9d223c7ea7b8d6e313b71d9f',
              '\xe9\x02\x89\x3a\x9d\x22\x3c\x7e\xa7\xb8\xd6\xe3\x13\xb7\x1d\x9f',
              '\x3a\x89\x02\xe9\x22\x9d\x7e\x3c\xa7\xb8\xd6\xe3\x13\xb7\x1d\x9f',
-             (0xe902893aL, 0x9d22, 0x3c7e, 0xa7, 0xb8, 0xd6e313b71d9fL),
-             0xe902893a9d223c7ea7b8d6e313b71d9fL,
+             (0xe902893a, 0x9d22, 0x3c7e, 0xa7, 0xb8, 0xd6e313b71d9f),
+             0xe902893a9d223c7ea7b8d6e313b71d9f,
              'urn:uuid:e902893a-9d22-3c7e-a7b8-d6e313b71d9f',
-             0xc7e9d22e902893aL, 0x27b8, uuid.RFC_4122, 3),
+             0xc7e9d22e902893a, 0x27b8, uuid.RFC_4122, 3),
             ('eb424026-6f54-4ef8-a4d0-bb658a1fc6cf',
              '{eb424026-6f54-4ef8-a4d0-bb658a1fc6cf}',
              'eb4240266f544ef8a4d0bb658a1fc6cf',
              '\xeb\x42\x40\x26\x6f\x54\x4e\xf8\xa4\xd0\xbb\x65\x8a\x1f\xc6\xcf',
              '\x26\x40\x42\xeb\x54\x6f\xf8\x4e\xa4\xd0\xbb\x65\x8a\x1f\xc6\xcf',
-             (0xeb424026L, 0x6f54, 0x4ef8, 0xa4, 0xd0, 0xbb658a1fc6cfL),
-             0xeb4240266f544ef8a4d0bb658a1fc6cfL,
+             (0xeb424026, 0x6f54, 0x4ef8, 0xa4, 0xd0, 0xbb658a1fc6cf),
+             0xeb4240266f544ef8a4d0bb658a1fc6cf,
              'urn:uuid:eb424026-6f54-4ef8-a4d0-bb658a1fc6cf',
-             0xef86f54eb424026L, 0x24d0, uuid.RFC_4122, 4),
+             0xef86f54eb424026, 0x24d0, uuid.RFC_4122, 4),
             ('f81d4fae-7dec-11d0-a765-00a0c91e6bf6',
              '{f81d4fae-7dec-11d0-a765-00a0c91e6bf6}',
              'f81d4fae7dec11d0a76500a0c91e6bf6',
              '\xf8\x1d\x4f\xae\x7d\xec\x11\xd0\xa7\x65\x00\xa0\xc9\x1e\x6b\xf6',
              '\xae\x4f\x1d\xf8\xec\x7d\xd0\x11\xa7\x65\x00\xa0\xc9\x1e\x6b\xf6',
-             (0xf81d4faeL, 0x7dec, 0x11d0, 0xa7, 0x65, 0x00a0c91e6bf6L),
-             0xf81d4fae7dec11d0a76500a0c91e6bf6L,
+             (0xf81d4fae, 0x7dec, 0x11d0, 0xa7, 0x65, 0x00a0c91e6bf6),
+             0xf81d4fae7dec11d0a76500a0c91e6bf6,
              'urn:uuid:f81d4fae-7dec-11d0-a765-00a0c91e6bf6',
-             0x1d07decf81d4faeL, 0x2765, uuid.RFC_4122, 1),
+             0x1d07decf81d4fae, 0x2765, uuid.RFC_4122, 1),
             ('fffefdfc-fffe-fffe-fffe-fffefdfcfbfa',
              '{fffefdfc-fffe-fffe-fffe-fffefdfcfbfa}',
              'fffefdfcfffefffefffefffefdfcfbfa',
              '\xff\xfe\xfd\xfc\xff\xfe\xff\xfe\xff\xfe\xff\xfe\xfd\xfc\xfb\xfa',
              '\xfc\xfd\xfe\xff\xfe\xff\xfe\xff\xff\xfe\xff\xfe\xfd\xfc\xfb\xfa',
-             (0xfffefdfcL, 0xfffe, 0xfffe, 0xff, 0xfe, 0xfffefdfcfbfaL),
-             0xfffefdfcfffefffefffefffefdfcfbfaL,
+             (0xfffefdfc, 0xfffe, 0xfffe, 0xff, 0xfe, 0xfffefdfcfbfa),
+             0xfffefdfcfffefffefffefffefdfcfbfa,
              'urn:uuid:fffefdfc-fffe-fffe-fffe-fffefdfcfbfa',
-             0xffefffefffefdfcL, 0x3ffe, uuid.RESERVED_FUTURE, None),
+             0xffefffefffefdfc, 0x3ffe, uuid.RESERVED_FUTURE, None),
             ('ffffffff-ffff-ffff-ffff-ffffffffffff',
              '{ffffffff-ffff-ffff-ffff-ffffffffffff}',
              'ffffffffffffffffffffffffffffffff',
              '\xff'*16,
              '\xff'*16,
-             (0xffffffffL, 0xffffL, 0xffffL, 0xff, 0xff, 0xffffffffffffL),
-             0xffffffffffffffffffffffffffffffffL,
+             (0xffffffff, 0xffff, 0xffff, 0xff, 0xff, 0xffffffffffff),
+             0xffffffffffffffffffffffffffffffff,
              'urn:uuid:ffffffff-ffff-ffff-ffff-ffffffffffff',
-             0xfffffffffffffffL, 0x3fff, uuid.RESERVED_FUTURE, None),
+             0xfffffffffffffff, 0x3fff, uuid.RESERVED_FUTURE, None),
             ]:
             equivalents = []
             # Construct each UUID in several different ways.
@@ -217,17 +217,17 @@
 
         # Field values out of range.
         badvalue(lambda: uuid.UUID(fields=(-1, 0, 0, 0, 0, 0)))
-        badvalue(lambda: uuid.UUID(fields=(0x100000000L, 0, 0, 0, 0, 0)))
+        badvalue(lambda: uuid.UUID(fields=(0x100000000, 0, 0, 0, 0, 0)))
         badvalue(lambda: uuid.UUID(fields=(0, -1, 0, 0, 0, 0)))
-        badvalue(lambda: uuid.UUID(fields=(0, 0x10000L, 0, 0, 0, 0)))
+        badvalue(lambda: uuid.UUID(fields=(0, 0x10000, 0, 0, 0, 0)))
         badvalue(lambda: uuid.UUID(fields=(0, 0, -1, 0, 0, 0)))
-        badvalue(lambda: uuid.UUID(fields=(0, 0, 0x10000L, 0, 0, 0)))
+        badvalue(lambda: uuid.UUID(fields=(0, 0, 0x10000, 0, 0, 0)))
         badvalue(lambda: uuid.UUID(fields=(0, 0, 0, -1, 0, 0)))
-        badvalue(lambda: uuid.UUID(fields=(0, 0, 0, 0x100L, 0, 0)))
+        badvalue(lambda: uuid.UUID(fields=(0, 0, 0, 0x100, 0, 0)))
         badvalue(lambda: uuid.UUID(fields=(0, 0, 0, 0, -1, 0)))
-        badvalue(lambda: uuid.UUID(fields=(0, 0, 0, 0, 0x100L, 0)))
+        badvalue(lambda: uuid.UUID(fields=(0, 0, 0, 0, 0x100, 0)))
         badvalue(lambda: uuid.UUID(fields=(0, 0, 0, 0, 0, -1)))
-        badvalue(lambda: uuid.UUID(fields=(0, 0, 0, 0, 0, 0x1000000000000L)))
+        badvalue(lambda: uuid.UUID(fields=(0, 0, 0, 0, 0, 0x1000000000000)))
 
         # Version number out of range.
         badvalue(lambda: uuid.UUID('00'*16, version=0))
@@ -235,7 +235,7 @@
 
         # Integer value out of range.
         badvalue(lambda: uuid.UUID(int=-1))
-        badvalue(lambda: uuid.UUID(int=1<<128L))
+        badvalue(lambda: uuid.UUID(int=1<<128))
 
         # Must supply exactly one of hex, bytes, fields, int.
         h, b, f, i = '00'*16, '\0'*16, (0, 0, 0, 0, 0, 0), 0
@@ -281,15 +281,15 @@
         badtype(lambda: setattr(u, 'node', 0))
 
     def check_node(self, node, source):
-        individual_group_bit = (node >> 40L) & 1
-        universal_local_bit = (node >> 40L) & 2
+        individual_group_bit = (node >> 40) & 1
+        universal_local_bit = (node >> 40) & 2
         message = "%012x doesn't look like a real MAC address" % node
         self.assertEqual(individual_group_bit, 0, message)
         self.assertEqual(universal_local_bit, 0, message)
         self.assertNotEqual(node, 0, message)
-        self.assertNotEqual(node, 0xffffffffffffL, message)
+        self.assertNotEqual(node, 0xffffffffffff, message)
         self.assert_(0 <= node, message)
-        self.assert_(node < (1L << 48), message)
+        self.assert_(node < (1 << 48), message)
 
         TestUUID.source2node[source] = node
         if TestUUID.last_node:
@@ -332,7 +332,7 @@
     def test_random_getnode(self):
         node = uuid._random_getnode()
         self.assert_(0 <= node)
-        self.assert_(node < (1L <<48))
+        self.assert_(node < (1 <<48))
 
     def test_unixdll_getnode(self):
         import sys
diff --git a/Lib/test/test_xdrlib.py b/Lib/test/test_xdrlib.py
index 8fc88a5..97f0cc9 100644
--- a/Lib/test/test_xdrlib.py
+++ b/Lib/test/test_xdrlib.py
@@ -15,7 +15,7 @@
         p.pack_uint(9)
         p.pack_bool(True)
         p.pack_bool(False)
-        p.pack_uhyper(45L)
+        p.pack_uhyper(45)
         p.pack_float(1.9)
         p.pack_double(1.9)
         p.pack_string(s)
@@ -40,7 +40,7 @@
         up.set_position(pos)
         self.assert_(up.unpack_bool() is False)
 
-        self.assertEqual(up.unpack_uhyper(), 45L)
+        self.assertEqual(up.unpack_uhyper(), 45)
         self.assertAlmostEqual(up.unpack_float(), 1.9)
         self.assertAlmostEqual(up.unpack_double(), 1.9)
         self.assertEqual(up.unpack_string(), s)
diff --git a/Lib/test/test_xmlrpc.py b/Lib/test/test_xmlrpc.py
index ccc1b60..795e097 100644
--- a/Lib/test/test_xmlrpc.py
+++ b/Lib/test/test_xmlrpc.py
@@ -14,7 +14,7 @@
 alist = [{'astring': 'foo@bar.baz.spam',
           'afloat': 7283.43,
           'anint': 2**20,
-          'ashortlong': 2L,
+          'ashortlong': 2,
           'anotherlist': ['.zyx.41'],
           'abase64': xmlrpclib.Binary("my dog has fleas"),
           'boolean': xmlrpclib.False,
@@ -96,15 +96,15 @@
         self.assertEquals(t2, t.__dict__)
 
     def test_dump_big_long(self):
-        self.assertRaises(OverflowError, xmlrpclib.dumps, (2L**99,))
+        self.assertRaises(OverflowError, xmlrpclib.dumps, (2**99,))
 
     def test_dump_bad_dict(self):
         self.assertRaises(TypeError, xmlrpclib.dumps, ({(1,2,3): 1},))
 
     def test_dump_big_int(self):
-        if sys.maxint > 2L**31-1:
+        if sys.maxint > 2**31-1:
             self.assertRaises(OverflowError, xmlrpclib.dumps,
-                              (int(2L**34),))
+                              (int(2**34),))
 
     def test_dump_none(self):
         value = alist + [None]
diff --git a/Lib/test/test_xrange.py b/Lib/test/test_xrange.py
index c0d1dbe..5225250 100644
--- a/Lib/test/test_xrange.py
+++ b/Lib/test/test_xrange.py
@@ -21,7 +21,7 @@
         c = 50
 
         self.assertEqual(list(xrange(a, a+2)), [a, a+1])
-        self.assertEqual(list(xrange(a+2, a, -1L)), [a+2, a+1])
+        self.assertEqual(list(xrange(a+2, a, -1)), [a+2, a+1])
         self.assertEqual(list(xrange(a+4, a, -2)), [a+4, a+2])
 
         seq = list(xrange(a, b, c))
diff --git a/Lib/test/test_zipimport.py b/Lib/test/test_zipimport.py
index 4e1a845..53c5504 100644
--- a/Lib/test/test_zipimport.py
+++ b/Lib/test/test_zipimport.py
@@ -31,7 +31,7 @@
         if mtime < 0x7fffffff:
             mtime = int(mtime)
         else:
-            mtime = int(-0x100000000L + long(mtime))
+            mtime = int(-0x100000000 + int(mtime))
     pyc = imp.get_magic() + struct.pack("<i", int(mtime)) + data
     return pyc
 
diff --git a/Lib/test/test_zlib.py b/Lib/test/test_zlib.py
index 4440942..0be9668 100644
--- a/Lib/test/test_zlib.py
+++ b/Lib/test/test_zlib.py
@@ -43,10 +43,10 @@
     def assertEqual32(self, seen, expected):
         # 32-bit values masked -- checksums on 32- vs 64- bit machines
         # This is important if bit 31 (0x08000000L) is set.
-        self.assertEqual(seen & 0x0FFFFFFFFL, expected & 0x0FFFFFFFFL)
+        self.assertEqual(seen & 0x0FFFFFFFF, expected & 0x0FFFFFFFF)
 
     def test_penguins(self):
-        self.assertEqual32(zlib.crc32("penguin", 0), 0x0e5c1a120L)
+        self.assertEqual32(zlib.crc32("penguin", 0), 0x0e5c1a120)
         self.assertEqual32(zlib.crc32("penguin", 1), 0x43b6aa94)
         self.assertEqual32(zlib.adler32("penguin", 0), 0x0bcf02f6)
         self.assertEqual32(zlib.adler32("penguin", 1), 0x0bd602f7)