diff --git a/Doc/glossary.rst b/Doc/glossary.rst
index f7a4b569..a2e9b02 100644
--- a/Doc/glossary.rst
+++ b/Doc/glossary.rst
@@ -16,7 +16,7 @@
       The typical Python prompt of the interactive shell when entering code for
       an indented code block.
 
-   Abstract Base Class
+   abstract base class
       Abstract Base Classes (abbreviated ABCs) complement :term:`duck-typing` by
       providing a way to define interfaces when other techniques like :func:`hasattr`
       would be clumsy. Python comes with many builtin ABCs for data structures
diff --git a/Doc/library/abc.rst b/Doc/library/abc.rst
index 21d3018..b03fc83 100644
--- a/Doc/library/abc.rst
+++ b/Doc/library/abc.rst
@@ -8,8 +8,8 @@
 .. sectionauthor:: Georg Brandl
 .. much of the content adapted from docstrings
 
-This module provides the infrastructure for defining :term:`abstract base
-classes` (ABCs) in Python, as outlined in :pep:`3119`; see the PEP for why this
+This module provides the infrastructure for defining an :term:`abstract base
+class` (ABCs) in Python, as outlined in :pep:`3119`; see the PEP for why this
 was added to Python. (See also :pep:`3141` and the :mod:`numbers` module
 regarding a type hierarchy for numbers based on ABCs.)
 
diff --git a/Doc/library/collections.rst b/Doc/library/collections.rst
index 7718c51..d2d4f47 100644
--- a/Doc/library/collections.rst
+++ b/Doc/library/collections.rst
@@ -37,42 +37,50 @@
 
 The collections module offers the following ABCs:
 
-=========================  ====================  ======================  ====================================================
-ABC                        Inherits              Abstract Methods        Mixin Methods
-=========================  ====================  ======================  ====================================================
-:class:`Container`                               ``__contains__``
-:class:`Hashable`                                ``__hash__``
-:class:`Iterable`                                ``__iter__``
-:class:`Iterator`          :class:`Iterable`     ``__next__``            ``__iter__``
-:class:`Sized`          			 ``__len__``
-
-:class:`Mapping`           :class:`Sized`,       ``__getitem__``,        ``__contains__``, ``keys``, ``items``, ``values``,
-                           :class:`Iterable`,    ``__len__``. and        ``get``, ``__eq__``, and ``__ne__``
-                           :class:`Container`    ``__iter__``
-
-:class:`MutableMapping`    :class:`Mapping`      ``__getitem__``         Inherited Mapping methods and
-                                                 ``__setitem__``,        ``pop``, ``popitem``, ``clear``, ``update``,
-                                                 ``__delitem__``,        and ``setdefault``
-						 ``__iter__``, and
-                                                 ``__len__``
-
-:class:`Sequence`          :class:`Sized`,       ``__getitem__``         ``__contains__``. ``__iter__``, ``__reversed__``.
-                           :class:`Iterable`,    and ``__len__``         ``index``, and ``count``
-                           :class:`Container`
-
-:class:`MutableSequnce`    :class:`Sequence`     ``__getitem__``         Inherited Sequence methods and
-                                                 ``__delitem__``,        ``append``, ``reverse``, ``extend``, ``pop``,
-                                                 ``insert``,             ``remove``, and ``__iadd__``
-                                                 and ``__len__``
-
-:class:`Set`               :class:`Sized`,       ``__len__``,            ``__le__``, ``__lt__``, ``__eq__``, ``__ne__``,
-                           :class:`Iterable`,    ``__iter__``, and       ``__gt__``, ``__ge__``, ``__and__``, ``__or__``
-                           :class:`Container`    ``__contains__``        ``__sub__``, ``__xor__``, and ``isdisjoint``
-
-:class:`MutableSet`        :class:`Set`          ``add`` and             Inherited Set methods and
-                                                 ``discard``             ``clear``, ``pop``, ``remove``, ``__ior__``,
-                                                                         ``__iand__``, ``__ixor__``, and ``__isub__``
-=========================  ====================  ======================  ====================================================
+=========================  =====================  ======================  ====================================================
+ABC                        Inherits               Abstract Methods        Mixin Methods
+=========================  =====================  ======================  ====================================================
+:class:`Container`                                ``__contains__``
+:class:`Hashable`                                 ``__hash__``
+:class:`Iterable`                                 ``__iter__``
+:class:`Iterator`          :class:`Iterable`      ``__next__``            ``__iter__``
+:class:`Sized`          			  ``__len__``
+:class:`Callable`                                 ``__call__``
+                                                  
+:class:`Sequence`          :class:`Sized`,        ``__getitem__``         ``__contains__``. ``__iter__``, ``__reversed__``.
+                           :class:`Iterable`,     and ``__len__``         ``index``, and ``count``
+                           :class:`Container`     
+                                                  
+:class:`MutableSequnce`    :class:`Sequence`      ``__getitem__``         Inherited Sequence methods and
+                                                  ``__delitem__``,        ``append``, ``reverse``, ``extend``, ``pop``,
+                                                  ``insert``,             ``remove``, and ``__iadd__``
+                                                  and ``__len__``
+                                                  
+:class:`Set`               :class:`Sized`,        ``__len__``,            ``__le__``, ``__lt__``, ``__eq__``, ``__ne__``,
+                           :class:`Iterable`,     ``__iter__``, and       ``__gt__``, ``__ge__``, ``__and__``, ``__or__``
+                           :class:`Container`     ``__contains__``        ``__sub__``, ``__xor__``, and ``isdisjoint``
+                                                  
+:class:`MutableSet`        :class:`Set`           ``add`` and             Inherited Set methods and
+                                                  ``discard``             ``clear``, ``pop``, ``remove``, ``__ior__``,
+                                                                          ``__iand__``, ``__ixor__``, and ``__isub__``
+                                                  
+:class:`Mapping`           :class:`Sized`,        ``__getitem__``,        ``__contains__``, ``keys``, ``items``, ``values``,
+                           :class:`Iterable`,     ``__len__``. and        ``get``, ``__eq__``, and ``__ne__``
+                           :class:`Container`     ``__iter__``
+                                                  
+:class:`MutableMapping`    :class:`Mapping`       ``__getitem__``         Inherited Mapping methods and
+                                                  ``__setitem__``,        ``pop``, ``popitem``, ``clear``, ``update``,
+                                                  ``__delitem__``,        and ``setdefault``
+						  ``__iter__``, and
+                                                  ``__len__``
+                                                  
+:class:`MappingView`       :class:`Sized`                                 ``__len__``
+:class:`KeysView`          :class:`MappingView`,                          ``__contains__``,
+                           :class:`Set`                                   ``__iter__``
+:class:`ItemsView`         :class:`MappingView`,                          ``__contains__``,
+                           :class:`Set`                                   ``__iter__``
+:class:`ValuesView`        :class:`MappingView`                           ``__contains__``, ``__iter__``
+=========================  =====================  ======================  ====================================================
 
 These ABCs allow us to ask classes or instances if they provide
 particular functionality, for example::
diff --git a/Doc/library/shutil.rst b/Doc/library/shutil.rst
index 5ab2f29..c295f29 100644
--- a/Doc/library/shutil.rst
+++ b/Doc/library/shutil.rst
@@ -78,18 +78,39 @@
    Unix command :program:`cp -p`.
 
 
-.. function:: copytree(src, dst[, symlinks])
+.. function:: ignore_patterns(\*patterns)
+
+   This factory function creates a function that can be used as a callable for
+   :func:`copytree`\'s *ignore* argument, ignoring files and directories that
+   match one of the glob-style *patterns* provided.  See the example below.
+
+
+.. function:: copytree(src, dst[, symlinks=False[, ignore=None]])
 
    Recursively copy an entire directory tree rooted at *src*.  The destination
-   directory, named by *dst*, must not already exist; it will be created as well as
-   missing parent directories. Permissions and times of directories are copied with
-   :func:`copystat`, individual files are copied using :func:`copy2`.   If
-   *symlinks* is true, symbolic links in the source tree are represented as
-   symbolic links in the new tree; if false or omitted, the contents of the linked
-   files are copied to the new tree.  If exception(s) occur, an :exc:`Error` is
-   raised with a list of reasons.
+   directory, named by *dst*, must not already exist; it will be created as well
+   as missing parent directories.  Permissions and times of directories are
+   copied with :func:`copystat`, individual files are copied using
+   :func:`copy2`.
 
-   The source code for this should be considered an example rather than a tool.
+   If *symlinks* is true, symbolic links in the source tree are represented as
+   symbolic links in the new tree; if false or omitted, the contents of the
+   linked files are copied to the new tree.
+
+   If *ignore* is given, it must be a callable that will receive as its
+   arguments the directory being visited by :func:`copytree`, and a list of its
+   contents, as returned by :func:`os.listdir`.  Since :func:`copytree` is
+   called recursively, the *ignore* callable will be called once for each
+   directory that is copied.  The callable must return a sequence of directory
+   and file names relative to the current directory (i.e. a subset of the items
+   in its second argument); these names will then be ignored in the copy
+   process.  :func:`ignore_patterns` can be used to create such a callable that
+   ignores names based on glob-style patterns.
+
+   If exception(s) occur, an :exc:`Error` is raised with a list of reasons.
+
+   The source code for this should be considered an example rather than the
+   ultimate tool.
 
 
 .. function:: rmtree(path[, ignore_errors[, onerror]])
diff --git a/Doc/library/stdtypes.rst b/Doc/library/stdtypes.rst
index 9107d03..a97a519 100644
--- a/Doc/library/stdtypes.rst
+++ b/Doc/library/stdtypes.rst
@@ -2027,7 +2027,7 @@
    files, like ttys, it makes sense to continue reading after an EOF is hit.)  Note
    that this method may call the underlying C function :cfunc:`fread` more than
    once in an effort to acquire as close to *size* bytes as possible. Also note
-   that when in non-blocking mode, less data than what was requested may be
+   that when in non-blocking mode, less data than was requested may be
    returned, even if no *size* parameter was given.
 
 
diff --git a/Doc/tools/sphinxext/opensearch.xml b/Doc/tools/sphinxext/opensearch.xml
index d672c2e..69cec80 100644
--- a/Doc/tools/sphinxext/opensearch.xml
+++ b/Doc/tools/sphinxext/opensearch.xml
@@ -1,14 +1,4 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<OpenSearchDescription xmlns="http://a9.com/-/spec/opensearch/1.1/">
-  <ShortName>Python Docs</ShortName>
-  <LongName>Python Documentation</LongName>
-  <Description>Search the Python documentation</Description>
-  <InputEncoding>utf-8</InputEncoding>
-  <Url type="text/html" method="get" template="{{ pathto('search') }}?">
-    <Param name="q" value="{searchTerms}" />
-    <Param name="check_keywords" value="yes" />
-    <Param name="area" value="default" />
-  </Url>
-  <Image height="16" width="16" type="image/x-icon">http://www.python.org/images/favicon16x16.ico</Image>
-</OpenSearchDescription>
-
+{% extends "!opensearch.xml" %}
+{% block extra -%}
+<Image height="16" width="16" type="image/x-icon">http://www.python.org/images/favicon16x16.ico</Image>
+{%- endblock %}
diff --git a/Doc/whatsnew/2.6.rst b/Doc/whatsnew/2.6.rst
index 21ccf9b..df5ccb6 100644
--- a/Doc/whatsnew/2.6.rst
+++ b/Doc/whatsnew/2.6.rst
@@ -1681,6 +1681,11 @@
   available, instead of restricting itself to protocol 1.
   (Contributed by W. Barnes; :issue:`1551443`.)
 
+* The :mod:`cgi` module will now read variables from the query string of an 
+  HTTP POST request.  This makes it possible to use form actions with 
+  URLs such as "/cgi-bin/add.py?category=1".  (Contributed by 
+  Alexandre Fiori and Nubis; :issue:`1817`.)
+
 * The :mod:`cmath` module underwent an extensive set of revisions,
   thanks to Mark Dickinson and Christian Heimes, that added some new
   features and greatly improved the accuracy of the computations.
@@ -2137,6 +2142,24 @@
 * The :mod:`sets` module has been deprecated; it's better to
   use the built-in :class:`set` and :class:`frozenset` types.
 
+* The :func:`shutil.copytree` function now has an optional **ignore** argument
+  that takes a callable object.  This callable will receive each directory path
+  and a list of the directory's contents, and returns a list of names that
+  will be ignored, not copied.  
+
+  The :mod:`shutil` module also provides an :func:`ignore_patterns`
+  function for use with this new parameter.
+  :func:`ignore_patterns` takes an arbitrary number of glob-style patterns
+  and will ignore any files and directories that match this pattern.
+  The following example copies a directory tree, but skip both SVN's internal
+  :file:`.svn` directories and Emacs backup 
+  files, which have names ending with '~'::
+
+      shutil.copytree('Doc/library', '/tmp/library', 
+                      ignore=shutil.ignore_patterns('*~', '.svn'))
+
+  (Contributed by Tarek Ziadé; :issue:`2663`.)
+
 * Integrating signal handling with GUI handling event loops
   like those used by Tkinter or GTk+ has long been a problem; most
   software ends up polling, waking up every fraction of a second.
@@ -2500,9 +2523,10 @@
       ...
     ValueError: malformed string
 
-The module also includes 
-:class:`NodeVisitor` and :class:`NodeTransformer` classes 
-for traversing and modifying an AST, and functions for common transformations such as changing line numbers.
+The module also includes :class:`NodeVisitor` and
+:class:`NodeTransformer` classes for traversing and modifying an AST,
+and functions for common transformations such as changing line
+numbers.
 
 .. ======================================================================
 
diff --git a/Lib/curses/textpad.py b/Lib/curses/textpad.py
index a05b82b..2b4b4cb 100644
--- a/Lib/curses/textpad.py
+++ b/Lib/curses/textpad.py
@@ -1,6 +1,7 @@
 """Simple textbox editing widget with Emacs-like keybindings."""
 
-import curses, ascii
+import curses
+import curses.ascii
 
 def rectangle(win, uly, ulx, lry, lrx):
     """Draw a rectangle with corners at the provided upper-left
@@ -54,7 +55,7 @@
         returning the index of the last non-blank character."""
         last = self.maxx
         while True:
-            if ascii.ascii(self.win.inch(y, last)) != ascii.SP:
+            if curses.ascii.ascii(self.win.inch(y, last)) != curses.ascii.SP:
                 last = min(self.maxx, last+1)
                 break
             elif last == 0:
@@ -76,7 +77,7 @@
                 pass
             if self.insert_mode:
                 (backy, backx) = self.win.getyx()
-                if ascii.isprint(oldch):
+                if curses.ascii.isprint(oldch):
                     self._insert_printable_char(oldch)
                     self.win.move(backy, backx)
 
@@ -84,12 +85,12 @@
         "Process a single editing command."
         (y, x) = self.win.getyx()
         self.lastcmd = ch
-        if ascii.isprint(ch):
+        if curses.ascii.isprint(ch):
             if y < self.maxy or x < self.maxx:
                 self._insert_printable_char(ch)
-        elif ch == ascii.SOH:                           # ^a
+        elif ch == curses.ascii.SOH:                           # ^a
             self.win.move(y, 0)
-        elif ch in (ascii.STX,curses.KEY_LEFT, ascii.BS,curses.KEY_BACKSPACE):
+        elif ch in (curses.ascii.STX,curses.KEY_LEFT, curses.ascii.BS,curses.KEY_BACKSPACE):
             if x > 0:
                 self.win.move(y, x-1)
             elif y == 0:
@@ -98,46 +99,46 @@
                 self.win.move(y-1, self._end_of_line(y-1))
             else:
                 self.win.move(y-1, self.maxx)
-            if ch in (ascii.BS, curses.KEY_BACKSPACE):
+            if ch in (curses.ascii.BS, curses.KEY_BACKSPACE):
                 self.win.delch()
-        elif ch == ascii.EOT:                           # ^d
+        elif ch == curses.ascii.EOT:                           # ^d
             self.win.delch()
-        elif ch == ascii.ENQ:                           # ^e
+        elif ch == curses.ascii.ENQ:                           # ^e
             if self.stripspaces:
                 self.win.move(y, self._end_of_line(y))
             else:
                 self.win.move(y, self.maxx)
-        elif ch in (ascii.ACK, curses.KEY_RIGHT):       # ^f
+        elif ch in (curses.ascii.ACK, curses.KEY_RIGHT):       # ^f
             if x < self.maxx:
                 self.win.move(y, x+1)
             elif y == self.maxy:
                 pass
             else:
                 self.win.move(y+1, 0)
-        elif ch == ascii.BEL:                           # ^g
+        elif ch == curses.ascii.BEL:                           # ^g
             return 0
-        elif ch == ascii.NL:                            # ^j
+        elif ch == curses.ascii.NL:                            # ^j
             if self.maxy == 0:
                 return 0
             elif y < self.maxy:
                 self.win.move(y+1, 0)
-        elif ch == ascii.VT:                            # ^k
+        elif ch == curses.ascii.VT:                            # ^k
             if x == 0 and self._end_of_line(y) == 0:
                 self.win.deleteln()
             else:
                 # first undo the effect of self._end_of_line
                 self.win.move(y, x)
                 self.win.clrtoeol()
-        elif ch == ascii.FF:                            # ^l
+        elif ch == curses.ascii.FF:                            # ^l
             self.win.refresh()
-        elif ch in (ascii.SO, curses.KEY_DOWN):         # ^n
+        elif ch in (curses.ascii.SO, curses.KEY_DOWN):         # ^n
             if y < self.maxy:
                 self.win.move(y+1, x)
                 if x > self._end_of_line(y+1):
                     self.win.move(y+1, self._end_of_line(y+1))
-        elif ch == ascii.SI:                            # ^o
+        elif ch == curses.ascii.SI:                            # ^o
             self.win.insertln()
-        elif ch in (ascii.DLE, curses.KEY_UP):          # ^p
+        elif ch in (curses.ascii.DLE, curses.KEY_UP):          # ^p
             if y > 0:
                 self.win.move(y-1, x)
                 if x > self._end_of_line(y-1):
@@ -155,7 +156,7 @@
             for x in range(self.maxx+1):
                 if self.stripspaces and x > stop:
                     break
-                result = result + chr(ascii.ascii(self.win.inch(y, x)))
+                result = result + chr(curses.ascii.ascii(self.win.inch(y, x)))
             if self.maxy > 0:
                 result = result + "\n"
         return result
diff --git a/Lib/fractions.py b/Lib/fractions.py
index 329a16f..3df628a 100755
--- a/Lib/fractions.py
+++ b/Lib/fractions.py
@@ -94,9 +94,8 @@
 
         if denominator == 0:
             raise ZeroDivisionError('Fraction(%s, 0)' % numerator)
-
-        numerator = numerator.__index__()
-        denominator = denominator.__index__()
+        numerator = operator.index(numerator)
+        denominator = operator.index(denominator)
         g = gcd(numerator, denominator)
         self._numerator = numerator // g
         self._denominator = denominator // g
diff --git a/Lib/http/client.py b/Lib/http/client.py
index 96bcd72..4a078d3 100644
--- a/Lib/http/client.py
+++ b/Lib/http/client.py
@@ -783,7 +783,7 @@
                         host_enc = self.host.encode("ascii")
                     except UnicodeEncodeError:
                         host_enc = self.host.encode("idna")
-                    if self.port == HTTP_PORT:
+                    if self.port == self.default_port:
                         self.putheader('Host', host_enc)
                     else:
                         host_enc = host_enc.decode("ascii")
diff --git a/Lib/subprocess.py b/Lib/subprocess.py
index 8df1034..e94fc2c 100644
--- a/Lib/subprocess.py
+++ b/Lib/subprocess.py
@@ -1149,7 +1149,12 @@
 
             input_offset = 0
             while read_set or write_set:
-                rlist, wlist, xlist = select.select(read_set, write_set, [])
+                try:
+                    rlist, wlist, xlist = select.select(read_set, write_set, [])
+                except select.error as e:
+                    if e.args[0] == errno.EINTR:
+                        continue
+                    raise
 
                 # XXX Rewrite these to use non-blocking I/O on the
                 # file objects; they are no longer using C stdio!
diff --git a/Lib/test/regrtest.py b/Lib/test/regrtest.py
index d523d5b..d47fde3 100755
--- a/Lib/test/regrtest.py
+++ b/Lib/test/regrtest.py
@@ -101,6 +101,8 @@
     curses -    Tests that use curses and will modify the terminal's
                 state and output modes.
 
+    lib2to3 -   Run the tests for 2to3 (They take a while.)
+
     largefile - It is okay to run some test that may create huge
                 files.  These tests can take a long time and may
                 consume >2GB of disk space temporarily.
@@ -173,8 +175,8 @@
 
 from test import support
 
-RESOURCE_NAMES = ('audio', 'curses', 'largefile', 'network', 'bsddb',
-                  'decimal', 'compiler', 'subprocess', 'urlfetch')
+RESOURCE_NAMES = ('audio', 'curses', 'lib2to3', 'largefile', 'network',
+                  'bsddb', 'decimal', 'compiler', 'subprocess', 'urlfetch')
 
 
 def usage(msg):
diff --git a/Lib/test/test_audioop.py b/Lib/test/test_audioop.py
index d43159a..689b0de 100644
--- a/Lib/test/test_audioop.py
+++ b/Lib/test/test_audioop.py
@@ -163,6 +163,10 @@
             self.assertEqual(audioop.getsample(data[1], 2, i), i)
             self.assertEqual(audioop.getsample(data[2], 4, i), i)
 
+    def test_negavitelen(self):
+        # from issue 3306, previously it segfaulted
+        self.assertRaises(audioop.error,
+            audioop.findmax, ''.join(chr(x) for x in range(256)), -2392392)
 
 def test_main():
     run_unittest(TestAudioop)
diff --git a/Lib/test/test_bz2.py b/Lib/test/test_bz2.py
index 4646f02..366ab7a 100644
--- a/Lib/test/test_bz2.py
+++ b/Lib/test/test_bz2.py
@@ -120,6 +120,17 @@
         self.assertEqual(list(iter(bz2f)), sio.readlines())
         bz2f.close()
 
+    def testClosedIteratorDeadlock(self):
+        # "Test that iteration on a closed bz2file releases the lock."
+        # http://bugs.python.org/issue3309
+        self.createTempFile()
+        bz2f = BZ2File(self.filename)
+        bz2f.close()
+        self.assertRaises(ValueError, bz2f.__next__)
+        # This call will deadlock of the above .__next__ call failed to
+        # release the lock.
+        self.assertRaises(ValueError, bz2f.readlines)
+
     def testWrite(self):
         # "Test BZ2File.write()"
         bz2f = BZ2File(self.filename, "w")
diff --git a/Lib/test/test_fractions.py b/Lib/test/test_fractions.py
index 3c8da77..4f8defb 100644
--- a/Lib/test/test_fractions.py
+++ b/Lib/test/test_fractions.py
@@ -62,11 +62,11 @@
 
         self.assertRaisesMessage(ZeroDivisionError, "Fraction(12, 0)",
                                  F, 12, 0)
-        self.assertRaises(AttributeError, F, 1.5)
-        self.assertRaises(AttributeError, F, 1.5 + 3j)
+        self.assertRaises(TypeError, F, 1.5)
+        self.assertRaises(TypeError, F, 1.5 + 3j)
 
-        self.assertRaises(AttributeError, F, F(1, 2), 3)
-        self.assertRaises(AttributeError, F, "3/2", 3)
+        self.assertRaises(TypeError, F, F(1, 2), 3)
+        self.assertRaises(TypeError, F, "3/2", 3)
 
     def testFromString(self):
         self.assertEquals((5, 1), _components(F("5")))
diff --git a/Lib/test/test_multiprocessing.py b/Lib/test/test_multiprocessing.py
index 4c5f7a5..5f5c588 100644
--- a/Lib/test/test_multiprocessing.py
+++ b/Lib/test/test_multiprocessing.py
@@ -1,3 +1,5 @@
+#!/usr/bin/env python
+
 #
 # Unit tests for the multiprocessing package
 #
diff --git a/Lib/test/test_sys.py b/Lib/test/test_sys.py
index cd8f565..f3c72e7 100644
--- a/Lib/test/test_sys.py
+++ b/Lib/test/test_sys.py
@@ -336,21 +336,6 @@
     def test_clear_type_cache(self):
         sys._clear_type_cache()
 
-    def test_compact_freelists(self):
-        sys._compact_freelists()
-        r = sys._compact_freelists()
-        ## freed blocks shouldn't change
-        #self.assertEqual(r[0][2], 0)
-        ## fill freelists
-        #ints = list(range(10000))
-        #floats = [float(i) for i in ints]
-        #del ints
-        #del floats
-        ## should free more than 100 blocks
-        #r = sys._compact_freelists()
-        #self.assert_(r[0][1] > 100, r[0][1])
-        #self.assert_(r[0][2] > 100, r[0][2])
-
     def test_ioencoding(self):
         import subprocess,os
         env = dict(os.environ)
diff --git a/Misc/ACKS b/Misc/ACKS
index dbb2035..7ce335e 100644
--- a/Misc/ACKS
+++ b/Misc/ACKS
@@ -145,6 +145,7 @@
 Matthew Dixon Cowles
 Christopher A. Craig
 Laura Creighton
+Simon Cross
 Drew Csillag
 John Cugini
 Tom Culliton
diff --git a/Modules/Setup.dist b/Modules/Setup.dist
index a790556..d2c8971 100644
--- a/Modules/Setup.dist
+++ b/Modules/Setup.dist
@@ -228,9 +228,11 @@
 #_md5 md5module.c md5.c
 
 
-# The _sha module implements the SHA checksum algorithm.
-# (NIST's Secure Hash Algorithm.)
+# The _sha module implements the SHA checksum algorithms.
+# (NIST's Secure Hash Algorithms.)
 #_sha shamodule.c
+#_sha256 sha256module.c
+#_sha512 sha512module.c
 
 
 # The _tkinter module.
diff --git a/Modules/_fileio.c b/Modules/_fileio.c
index 71553ba..f520f0c 100644
--- a/Modules/_fileio.c
+++ b/Modules/_fileio.c
@@ -278,7 +278,6 @@
 	ret = -1;
 
  done:
-	PyMem_Free(name);
 	return ret;
 }
 
diff --git a/Modules/audioop.c b/Modules/audioop.c
index c660501..c54e512 100644
--- a/Modules/audioop.c
+++ b/Modules/audioop.c
@@ -575,7 +575,7 @@
         }
         len1 >>= 1;
     
-        if ( len1 < len2 ) {
+        if ( len2 < 0 || len1 < len2 ) {
                 PyErr_SetString(AudioopError, "Input sample should be longer");
                 return 0;
         }
diff --git a/Modules/bz2module.c b/Modules/bz2module.c
index db10f31..562198b 100644
--- a/Modules/bz2module.c
+++ b/Modules/bz2module.c
@@ -1264,6 +1264,7 @@
 	PyBytesObject* ret;
 	ACQUIRE_LOCK(self);
 	if (self->mode == MODE_CLOSED) {
+                RELEASE_LOCK(self);
 		PyErr_SetString(PyExc_ValueError,
 				"I/O operation on closed file");
 		return NULL;
diff --git a/Modules/cmathmodule.c b/Modules/cmathmodule.c
index eec618e..67df5c3 100644
--- a/Modules/cmathmodule.c
+++ b/Modules/cmathmodule.c
@@ -839,8 +839,10 @@
 	errno = 0;
 	PyFPE_START_PROTECT("complex function", return 0)
 	x = c_log(x);
-	if (PyTuple_GET_SIZE(args) == 2)
-		x = c_quot(x, c_log(y));
+	if (PyTuple_GET_SIZE(args) == 2) {
+		y = c_log(y);
+		x = c_quot(x, y);
+	}
 	PyFPE_END_PROTECT(x)
 	if (errno != 0)
 		return math_error();
diff --git a/Modules/timemodule.c b/Modules/timemodule.c
index 1954d0c..d2817fb 100644
--- a/Modules/timemodule.c
+++ b/Modules/timemodule.c
@@ -641,8 +641,6 @@
 {
 	struct tm buf;
 	time_t tt;
-	tt = time(&tt);
-	buf = *localtime(&tt);
 	if (!gettmarg(tup, &buf))
 		return NULL;
 	tt = mktime(&buf);
diff --git a/Objects/abstract.c b/Objects/abstract.c
index 60a5e84..f15883e 100644
--- a/Objects/abstract.c
+++ b/Objects/abstract.c
@@ -1632,7 +1632,7 @@
 		return m->sq_item(s, i);
 	}
 
-	return type_error("'%.200s' object is unindexable", s);
+	return type_error("'%.200s' object does not support indexing", s);
 }
 
 PyObject *
diff --git a/Python/ceval.c b/Python/ceval.c
index ec279bf..c75caf6 100644
--- a/Python/ceval.c
+++ b/Python/ceval.c
@@ -617,18 +617,20 @@
 	COMPARE_OP is often followed by JUMP_IF_FALSE or JUMP_IF_TRUE.  And,
 	those opcodes are often followed by a POP_TOP.
 
-	Verifying the prediction costs a single high-speed test of register
+	Verifying the prediction costs a single high-speed test of a register
 	variable against a constant.  If the pairing was good, then the
-	processor has a high likelihood of making its own successful branch
-	prediction which results in a nearly zero overhead transition to the
-	next opcode.
+	processor's own internal branch predication has a high likelihood of
+	success, resulting in a nearly zero-overhead transition to the
+	next opcode.  A successful prediction saves a trip through the eval-loop
+	including its two unpredictable branches, the HAS_ARG test and the 
+	switch-case.  Combined with the processor's internal branch prediction,
+	a successful PREDICT has the effect of making the two opcodes run as if 
+	they were a single new opcode with the bodies combined.
 
-	A successful prediction saves a trip through the eval-loop including
-	its two unpredictable branches, the HAS_ARG test and the switch-case.
-
-        If collecting opcode statistics, turn off prediction so that
-	statistics are accurately maintained (the predictions bypass
-	the opcode frequency counter updates).
+    If collecting opcode statistics, your choices are to either keep the
+	predictions turned-on and interpret the results as if some opcodes
+	had been combined or turn-off predictions so that the opcode frequency
+	counter updates for both opcodes.
 */
 
 #ifdef DYNAMIC_EXECUTION_PROFILE
diff --git a/Python/pythonrun.c b/Python/pythonrun.c
index d13563f..3a6cc91 100644
--- a/Python/pythonrun.c
+++ b/Python/pythonrun.c
@@ -229,14 +229,14 @@
 	if (install_sigs)
 		initsigs(); /* Signal handling stuff, including initintr() */
 		
-    /* Initialize warnings. */
-    _PyWarnings_Init();
-    if (PySys_HasWarnOptions()) {
-        PyObject *warnings_module = PyImport_ImportModule("warnings");
-        if (!warnings_module)
-            PyErr_Clear();
-        Py_XDECREF(warnings_module);
-    }
+	/* Initialize warnings. */
+	_PyWarnings_Init();
+	if (PySys_HasWarnOptions()) {
+		PyObject *warnings_module = PyImport_ImportModule("warnings");
+		if (!warnings_module)
+			PyErr_Clear();
+		Py_XDECREF(warnings_module);
+	}
 
 	initmain(); /* Module __main__ */
 	if (!Py_NoSiteFlag)
@@ -1246,7 +1246,7 @@
 	PyException_SetTraceback(v, tb);
 	if (exception == NULL)
 		return;
-        /* Now we know v != NULL too */
+	/* Now we know v != NULL too */
 	if (set_sys_last_vars) {
 		PySys_SetObject("last_type", exception);
 		PySys_SetObject("last_value", v);
@@ -2096,14 +2096,14 @@
 PyAPI_FUNC(PyObject *)
 PyRun_File(FILE *fp, const char *p, int s, PyObject *g, PyObject *l)
 {
-        return PyRun_FileExFlags(fp, p, s, g, l, 0, NULL);
+	return PyRun_FileExFlags(fp, p, s, g, l, 0, NULL);
 }
 
 #undef PyRun_FileEx
 PyAPI_FUNC(PyObject *)
 PyRun_FileEx(FILE *fp, const char *p, int s, PyObject *g, PyObject *l, int c)
 {
-        return PyRun_FileExFlags(fp, p, s, g, l, c, NULL);
+	return PyRun_FileExFlags(fp, p, s, g, l, c, NULL);
 }
 
 #undef PyRun_FileFlags
@@ -2111,7 +2111,7 @@
 PyRun_FileFlags(FILE *fp, const char *p, int s, PyObject *g, PyObject *l,
 		PyCompilerFlags *flags)
 {
-        return PyRun_FileExFlags(fp, p, s, g, l, 0, flags);
+	return PyRun_FileExFlags(fp, p, s, g, l, 0, flags);
 }
 
 #undef PyRun_SimpleFile