diff --git a/Doc/glossary.rst b/Doc/glossary.rst
index a2e9b02..ab11a83 100644
--- a/Doc/glossary.rst
+++ b/Doc/glossary.rst
@@ -100,6 +100,14 @@
       of :class:`dict` much resembles that for :class:`list`, but the keys can
       be any object with a :meth:`__hash__` function, not just integers starting
       from zero.  Called a hash in Perl.
+
+   docstring
+      A docstring ("documentation string") is a string literal that appears as
+      the first thing in a class or function suite.  While ignored when the
+      suite is executed, it is recognized by the compiler and put into the
+      :attr:`__doc__` attribute of the class or function.  Since it is available
+      via introspection, it is the canonical place for documentation of the
+      object.
     
    duck-typing 
       Pythonic programming style that determines an object's type by inspection
diff --git a/Doc/library/itertools.rst b/Doc/library/itertools.rst
index 63cace6..79a69ea 100644
--- a/Doc/library/itertools.rst
+++ b/Doc/library/itertools.rst
@@ -33,18 +33,11 @@
 Likewise, the functional tools are designed to work well with the high-speed
 functions provided by the :mod:`operator` module.
 
-The module author welcomes suggestions for other basic building blocks to be
-added to future versions of the module.
-
 Whether cast in pure python form or compiled code, tools that use iterators are
-more memory efficient (and faster) than their list based counterparts. Adopting
+more memory efficient (and often faster) than their list based counterparts. Adopting
 the principles of just-in-time manufacturing, they create data when and where
 needed instead of consuming memory with the computer equivalent of "inventory".
 
-The performance advantage of iterators becomes more acute as the number of
-elements increases -- at some point, lists grow large enough to severely impact
-memory cache performance and start running slowly.
-
 
 .. seealso::
 
@@ -517,55 +510,35 @@
 
 .. testcode::
 
-   def take(n, seq):
-       return list(islice(seq, n))
+   def take(n, iterable):
+       "Return first n items of the iterable as a list"
+       return list(islice(iterable, n))
 
-   def enumerate(iterable):
-       return zip(count(), iterable)
+   def enumerate(iterable, start=0):
+       return zip(count(start), iterable)
 
-   def tabulate(function):
+   def tabulate(function, start=0):
        "Return function(0), function(1), ..."
-       return map(function, count())
-
-   def items(mapping):
-       return zip(mapping.keys(), mapping.values())
+       return map(function, count(start))
 
    def nth(iterable, n):
-       "Returns the nth item or raise StopIteration"
-       return next(islice(iterable, n, None))
+       "Returns the nth item or empty list"
+       return list(islice(iterable, n, n+1))
 
-   def all(seq, pred=None):
-       "Returns True if pred(x) is true for every element in the iterable"
-       for elem in filterfalse(pred, seq):
-           return False
-       return True
+   def quantify(iterable, pred=bool):
+       "Count how many times the predicate is true"
+       return sum(map(pred, iterable))
 
-   def any(seq, pred=None):
-       "Returns True if pred(x) is true for at least one element in the iterable"
-       for elem in filter(pred, seq):
-           return True
-       return False
-
-   def no(seq, pred=None):
-       "Returns True if pred(x) is false for every element in the iterable"
-       for elem in filter(pred, seq):
-           return False
-       return True
-
-   def quantify(seq, pred=None):
-       "Count how many times the predicate is true in the sequence"
-       return sum(map(pred, seq))
-
-   def padnone(seq):
+   def padnone(iterable):
        """Returns the sequence elements and then returns None indefinitely.
 
        Useful for emulating the behavior of the built-in map() function.
        """
-       return chain(seq, repeat(None))
+       return chain(iterable, repeat(None))
 
-   def ncycles(seq, n):
+   def ncycles(iterable, n):
        "Returns the sequence elements n times"
-       return chain.from_iterable(repeat(seq, n))
+       return chain.from_iterable(repeat(iterable, n))
 
    def dotproduct(vec1, vec2):
        return sum(map(operator.mul, vec1, vec2))
@@ -616,7 +589,21 @@
 
    def compress(data, selectors):
        "compress('abcdef', [1,0,1,0,1,1]) --> a c e f"
-       for d, s in zip(data, selectors):
-           if s:
-               yield d
+       decorated = zip(data, selectors)
+       filtered =  filter(operator.itemgetter(1), decorated)
+       return map(operator.itemgetter(0), filtered)
 
+   def combinations_with_replacement(iterable, r):
+       "combinations_with_replacement('ABC', 3) --> AA AB AC BB BC CC"
+       pool = tuple(iterable)
+       n = len(pool)
+       indices = [0] * r
+       yield tuple(pool[i] for i in indices)
+       while True:
+           for i in reversed(range(r)):
+               if indices[i] != n - 1:
+                   break
+           else:
+               return
+           indices[i:] = [indices[i] + 1] * (r - i)
+           yield tuple(pool[i] for i in indices)
diff --git a/Doc/library/logging.rst b/Doc/library/logging.rst
index 3f6b860..734e3b2 100644
--- a/Doc/library/logging.rst
+++ b/Doc/library/logging.rst
@@ -1647,7 +1647,7 @@
    The system will save old log files by appending extensions to the filename.
    The extensions are date-and-time based, using the strftime format
    ``%Y-%m-%d_%H-%M-%S`` or a leading portion thereof, depending on the
-   rollover interval. 
+   rollover interval.
    If the *utc* argument is true, times in UTC will be used; otherwise
    local time is used.
 
@@ -2315,6 +2315,10 @@
 in the ``logging`` package's namespace). The ``level`` is interpreted as for
 loggers, and ``NOTSET`` is taken to mean "log everything".
 
+.. versionchanged:: 2.6
+  Added support for resolving the handler's class as a dotted module and class
+  name.
+
 The ``formatter`` entry indicates the key name of the formatter for this
 handler. If blank, a default formatter (``logging._defaultFormatter``) is used.
 If a name is specified, it must appear in the ``[formatters]`` section and have
diff --git a/Doc/library/re.rst b/Doc/library/re.rst
index 5831364..a6ebc22 100644
--- a/Doc/library/re.rst
+++ b/Doc/library/re.rst
@@ -571,17 +571,20 @@
 .. function:: findall(pattern, string[, flags])
 
    Return all non-overlapping matches of *pattern* in *string*, as a list of
-   strings.  If one or more groups are present in the pattern, return a list of
-   groups; this will be a list of tuples if the pattern has more than one group.
-   Empty matches are included in the result unless they touch the beginning of
-   another match.
+   strings.  The *string* is scanned left-to-right, and matches are returned in
+   the order found.  If one or more groups are present in the pattern, return a
+   list of groups; this will be a list of tuples if the pattern has more than
+   one group.  Empty matches are included in the result unless they touch the
+   beginning of another match.
 
 
 .. function:: finditer(pattern, string[, flags])
 
    Return an :term:`iterator` yielding :class:`MatchObject` instances over all
-   non-overlapping matches for the RE *pattern* in *string*.  Empty matches are
-   included in the result unless they touch the beginning of another match.
+   non-overlapping matches for the RE *pattern* in *string*.  The *string* is
+   scanned left-to-right, and matches are returned in the order found.  Empty
+   matches are included in the result unless they touch the beginning of another
+   match.
 
 
 .. function:: sub(pattern, repl, string[, count])
diff --git a/Doc/library/string.rst b/Doc/library/string.rst
index faf5fed..5049dc1 100644
--- a/Doc/library/string.rst
+++ b/Doc/library/string.rst
@@ -360,10 +360,11 @@
 character of ``'0'``.
 
 The *precision* is a decimal number indicating how many digits should be
-displayed after the decimal point for a floating point value.  For non-number
-types the field indicates the maximum field size - in other words, how many
-characters will be used from the field content. The *precision* is ignored for
-integer values.
+displayed after the decimal point for a floating point value formatted with
+``'f'`` and ``'F'``, or before and after the decimal point for a floating point
+value formatted with ``'g'`` or ``'G'``.  For non-number types the field
+indicates the maximum field size - in other words, how many characters will be
+used from the field content. The *precision* is ignored for integer values.
 
 Finally, the *type* determines how the data should be presented.
 
@@ -391,7 +392,7 @@
    |         | the current locale setting to insert the appropriate     |
    |         | number separator characters.                             |
    +---------+----------------------------------------------------------+
-   | None    | the same as ``'d'``                                      |
+   | None    | The same as ``'d'``.                                     |
    +---------+----------------------------------------------------------+
                                                                          
 The available presentation types for floating point and decimal values are:
@@ -412,10 +413,13 @@
    +---------+----------------------------------------------------------+
    | ``'g'`` | General format. This prints the number as a fixed-point  |
    |         | number, unless the number is too large, in which case    |
-   |         | it switches to ``'e'`` exponent notation.                |
+   |         | it switches to ``'e'`` exponent notation. Infinity and   |
+   |         | NaN values are formatted as ``inf``, ``-inf`` and        |
+   |         | ``nan``, respectively.                                   |
    +---------+----------------------------------------------------------+
    | ``'G'`` | General format. Same as ``'g'`` except switches to       |
-   |         | ``'E'`` if the number gets to large.                     |
+   |         | ``'E'`` if the number gets to large. The representations |
+   |         | of infinity and NaN are uppercased, too.                 |
    +---------+----------------------------------------------------------+
    | ``'n'`` | Number. This is the same as ``'g'``, except that it uses |
    |         | the current locale setting to insert the appropriate     |
@@ -424,7 +428,7 @@
    | ``'%'`` | Percentage. Multiplies the number by 100 and displays    |
    |         | in fixed (``'f'``) format, followed by a percent sign.   |
    +---------+----------------------------------------------------------+
-   | None    | the same as ``'g'``                                      |
+   | None    | The same as ``'g'``.                                     |
    +---------+----------------------------------------------------------+
 
 
diff --git a/Doc/reference/compound_stmts.rst b/Doc/reference/compound_stmts.rst
index a3665e7..9dd2c99 100644
--- a/Doc/reference/compound_stmts.rst
+++ b/Doc/reference/compound_stmts.rst
@@ -433,7 +433,7 @@
 when the function is called.
 
 The function definition does not execute the function body; this gets executed
-only when the function is called.
+only when the function is called. [#]_
 
 .. index::
   statement: @
@@ -535,6 +535,7 @@
    pair: name; binding
    pair: execution; frame
    single: inheritance
+   single: docstring
 
 A class definition defines a class object (see section :ref:`types`):
 
@@ -552,10 +553,10 @@
 then executed in a new execution frame (see section :ref:`naming`), using a
 newly created local namespace and the original global namespace. (Usually, the
 suite contains only function definitions.)  When the class's suite finishes
-execution, its execution frame is discarded but its local namespace is saved.  A
-class object is then created using the inheritance list for the base classes and
-the saved local namespace for the attribute dictionary.  The class name is bound
-to this class object in the original local namespace.
+execution, its execution frame is discarded but its local namespace is
+saved. [#]_ A class object is then created using the inheritance list for the
+base classes and the saved local namespace for the attribute dictionary.  The
+class name is bound to this class object in the original local namespace.
 
 Classes can also be decorated; as with functions, ::
 
@@ -597,3 +598,11 @@
 .. [#] Currently, control "flows off the end" except in the case of an exception or the
    execution of a :keyword:`return`, :keyword:`continue`, or :keyword:`break`
    statement.
+
+.. [#] A string literal appearing as the first statement in the function body is
+   transformed into the function's ``__doc__`` attribute and therefore the
+   function's :term:`docstring`.
+
+.. [#] A string literal appearing as the first statement in the class body is
+   transformed into the namespace's ``__doc__`` item and therefore the class's
+   :term:`docstring`.
diff --git a/Doc/reference/datamodel.rst b/Doc/reference/datamodel.rst
index 3d531c7..8f95700 100644
--- a/Doc/reference/datamodel.rst
+++ b/Doc/reference/datamodel.rst
@@ -1435,6 +1435,10 @@
 Notes on using *__slots__*
 """"""""""""""""""""""""""
 
+* When inheriting from a class without *__slots__*, the *__dict__* attribute of
+  that class will always be accessible, so a *__slots__* definition in the
+  subclass is meaningless.
+
 * Without a *__dict__* variable, instances cannot be assigned new variables not
   listed in the *__slots__* definition.  Attempts to assign to an unlisted
   variable name raises :exc:`AttributeError`. If dynamic assignment of new
diff --git a/Doc/tutorial/inputoutput.rst b/Doc/tutorial/inputoutput.rst
index cc2a392..cbca95b 100644
--- a/Doc/tutorial/inputoutput.rst
+++ b/Doc/tutorial/inputoutput.rst
@@ -355,6 +355,16 @@
      File "<stdin>", line 1, in ?
    ValueError: I/O operation on closed file
 
+It is good practice to use the :keyword:`with` keyword when dealing with file
+objects.  This has the advantage that the file is properly closed after its
+suite finishes, even if an exception is raised on the way.  It is also much
+shorter than writing equivalent :keyword:`try`\ -\ :keyword:`finally` blocks::
+
+    >>> with open('/tmp/workfile', 'r') as f:
+    ...     read_data = f.read()
+    >>> f.closed
+    True
+
 File objects have some additional methods, such as :meth:`isatty` and
 :meth:`truncate` which are less frequently used; consult the Library Reference
 for a complete guide to file objects.
diff --git a/Doc/whatsnew/2.6.rst b/Doc/whatsnew/2.6.rst
index 5cf29cb..203091f 100644
--- a/Doc/whatsnew/2.6.rst
+++ b/Doc/whatsnew/2.6.rst
@@ -1324,14 +1324,6 @@
 all, and only exists to allow checking if an object is a number by
 doing ``isinstance(obj, Number)``.
 
-Numbers are further divided into :class:`Exact` and :class:`Inexact`.
-Exact numbers can represent values precisely and operations never
-round off the results or introduce tiny errors that may break the
-commutativity and associativity properties; inexact numbers may
-perform such rounding or introduce small errors.  Integers, long
-integers, and rational numbers are exact, while floating-point
-and complex numbers are inexact.
-
 :class:`Complex` is a subclass of :class:`Number`.  Complex numbers
 can undergo the basic operations of addition, subtraction,
 multiplication, division, and exponentiation, and you can retrieve the
@@ -1449,13 +1441,15 @@
   it will be returned if *iterator* has been exhausted; otherwise,
   the :exc:`StopIteration` exception will be raised.  (:issue:`2719`)
 
-* Tuples now have an :meth:`index` method matching the list type's
-  :meth:`index` method::
+* Tuples now have :meth:`index` and :meth:`count` methods matching the
+  list type's :meth:`index` and :meth:`count` methods::
 
     >>> t = (0,1,2,3,4)
     >>> t.index(3)
     3
 
+  (Contributed by Raymond Hettinger)
+
 * The built-in types now have improved support for extended slicing syntax,
   where various combinations of ``(start, stop, step)`` are supplied.
   Previously, the support was partial and certain corner cases wouldn't work.
@@ -1545,7 +1539,8 @@
 
   * :func:`~math.sum` adds up the stream of numbers from an iterable,
     and is careful to avoid loss of precision by calculating partial sums.
-    (Contributed by Jean Brouwers; :issue:`2819`.)
+    (Contributed by Jean Brouwers, Raymond Hettinger, and Mark Dickinson;
+    :issue:`2819`.)
 
   * The inverse hyperbolic functions :func:`~math.acosh`, :func:`~math.asinh`
     and :func:`~math.atanh`.
@@ -1596,8 +1591,8 @@
 * The string :meth:`translate` method now accepts ``None`` as the
   translation table parameter, which is treated as the identity
   transformation.   This makes it easier to carry out operations
-  that only delete characters.  (Contributed by Bengt Richter;
-  :issue:`1193128`.)
+  that only delete characters.  (Contributed by Bengt Richter and
+  implemented by Raymond Hettinger; :issue:`1193128`.)
 
 * The built-in :func:`dir` function now checks for a :meth:`__dir__`
   method on the objects it receives.  This method must return a list
diff --git a/Lib/distutils/unixccompiler.py b/Lib/distutils/unixccompiler.py
index 87ce921..d65ab32 100644
--- a/Lib/distutils/unixccompiler.py
+++ b/Lib/distutils/unixccompiler.py
@@ -75,8 +75,7 @@
     if 'ARCHFLAGS' in os.environ and not stripArch:
         # User specified different -arch flags in the environ,
         # see also distutils.sysconfig
-        compiler_so = compiler_so + ' ' + os.environ['ARCHFLAGS']
-
+        compiler_so = compiler_so + os.environ['ARCHFLAGS'].split()
 
     if stripSysroot:
         try:
diff --git a/Lib/imghdr.py b/Lib/imghdr.py
index 38732e6..c00c816 100644
--- a/Lib/imghdr.py
+++ b/Lib/imghdr.py
@@ -8,7 +8,7 @@
 
 def what(file, h=None):
     if h is None:
-        if type(file) == type(''):
+        if isinstance(file, str):
             f = open(file, 'rb')
             h = f.read(32)
         else:
diff --git a/Lib/logging/config.py b/Lib/logging/config.py
index 4123506..a9a4e62 100644
--- a/Lib/logging/config.py
+++ b/Lib/logging/config.py
@@ -143,7 +143,10 @@
             fmt = cp.get(sectname, "formatter")
         else:
             fmt = ""
-        klass = eval(klass, vars(logging))
+        try:
+            klass = eval(klass, vars(logging))
+        except (AttributeError, NameError):
+            klass = _resolve(klass)
         args = cp.get(sectname, "args")
         args = eval(args, vars(logging))
         h = klass(*args)
diff --git a/Lib/pydoc.py b/Lib/pydoc.py
index cd9490e..09e1d25 100755
--- a/Lib/pydoc.py
+++ b/Lib/pydoc.py
@@ -1342,7 +1342,7 @@
     (fd, filename) = tempfile.mkstemp()
     os.close(fd)
     try:
-        if hasattr(os, 'system') and os.system('more %s' % filename) == 0:
+        if hasattr(os, 'system') and os.system('more "%s"' % filename) == 0:
             return lambda text: pipepager(text, 'more')
         else:
             return ttypager
@@ -1370,7 +1370,7 @@
     file.write(text)
     file.close()
     try:
-        os.system(cmd + ' ' + filename)
+        os.system(cmd + ' "' + filename + '"')
     finally:
         os.unlink(filename)
 
diff --git a/Lib/sqlite3/test/regression.py b/Lib/sqlite3/test/regression.py
index 5e89a6c..433cae2 100644
--- a/Lib/sqlite3/test/regression.py
+++ b/Lib/sqlite3/test/regression.py
@@ -146,7 +146,8 @@
         # decoding errors disappeared. This verifies they're back again.
         failure = None
         try:
-            self.con.execute("select 'xxx' || ? || 'yyy' colname", (bytes(bytearray([250])),)).fetchone()
+            self.con.execute("select 'xxx' || ? || 'yyy' colname",
+                             (bytes(bytearray([250])),)).fetchone()
             failure = "should have raised an OperationalError with detailed description"
         except sqlite.OperationalError as e:
             msg = e.args[0]
@@ -155,6 +156,20 @@
         if failure:
             self.fail(failure)
 
+    def CheckRegisterAdapter(self):
+        """
+        See issue 3312.
+        """
+        self.assertRaises(TypeError, sqlite.register_adapter, {}, None)
+
+    def CheckSetIsolationLevel(self):
+        """
+        See issue 3312.
+        """
+        con = sqlite.connect(":memory:")
+        setattr(con, "isolation_level", "\xe9")
+
+
 def suite():
     regression_suite = unittest.makeSuite(RegressionTests, "Check")
     return unittest.TestSuite((regression_suite,))
diff --git a/Lib/test/pystone.py b/Lib/test/pystone.py
index bbf43cc..614551f 100755
--- a/Lib/test/pystone.py
+++ b/Lib/test/pystone.py
@@ -128,7 +128,11 @@
         IntLoc1 = Proc2(IntLoc1)
 
     benchtime = clock() - starttime - nulltime
-    return benchtime, (loops / benchtime)
+    if benchtime == 0.0:
+        loopsPerBenchtime = 0.0
+    else:
+        loopsPerBenchtime = (loops / benchtime)
+    return benchtime, loopsPerBenchtime
 
 def Proc1(PtrParIn):
     PtrParIn.PtrComp = NextRecord = PtrGlb.copy()
diff --git a/Lib/test/test_audioop.py b/Lib/test/test_audioop.py
index 689b0de..1cd80a1 100644
--- a/Lib/test/test_audioop.py
+++ b/Lib/test/test_audioop.py
@@ -163,7 +163,7 @@
             self.assertEqual(audioop.getsample(data[1], 2, i), i)
             self.assertEqual(audioop.getsample(data[2], 4, i), i)
 
-    def test_negavitelen(self):
+    def test_negativelen(self):
         # from issue 3306, previously it segfaulted
         self.assertRaises(audioop.error,
             audioop.findmax, ''.join(chr(x) for x in range(256)), -2392392)
diff --git a/Lib/test/test_itertools.py b/Lib/test/test_itertools.py
index 3957f41..ee50e2a 100644
--- a/Lib/test/test_itertools.py
+++ b/Lib/test/test_itertools.py
@@ -1204,52 +1204,32 @@
 [22]
 [25, 26, 27, 28]
 
->>> def take(n, seq):
-...     return list(islice(seq, n))
+>>> def take(n, iterable):
+...     "Return first n items of the iterable as a list"
+...     return list(islice(iterable, n))
 
->>> def enumerate(iterable):
-...     return zip(count(), iterable)
+>>> def enumerate(iterable, start=0):
+...     return zip(count(start), iterable)
 
->>> def tabulate(function):
+>>> def tabulate(function, start=0):
 ...     "Return function(0), function(1), ..."
-...     return map(function, count())
-
->>> def iteritems(mapping):
-...     return zip(mapping.keys(), mapping.values())
+...     return map(function, count(start))
 
 >>> def nth(iterable, n):
-...     "Returns the nth item"
+...     "Returns the nth item or empty list"
 ...     return list(islice(iterable, n, n+1))
 
->>> def all(seq, pred=None):
-...     "Returns True if pred(x) is true for every element in the iterable"
-...     for elem in filterfalse(pred, seq):
-...         return False
-...     return True
+>>> def quantify(iterable, pred=bool):
+...     "Count how many times the predicate is true"
+...     return sum(map(pred, iterable))
 
->>> def any(seq, pred=None):
-...     "Returns True if pred(x) is true for at least one element in the iterable"
-...     for elem in filter(pred, seq):
-...         return True
-...     return False
-
->>> def no(seq, pred=None):
-...     "Returns True if pred(x) is false for every element in the iterable"
-...     for elem in filter(pred, seq):
-...         return False
-...     return True
-
->>> def quantify(seq, pred=None):
-...     "Count how many times the predicate is true in the sequence"
-...     return sum(map(pred, seq))
-
->>> def padnone(seq):
+>>> def padnone(iterable):
 ...     "Returns the sequence elements and then returns None indefinitely"
-...     return chain(seq, repeat(None))
+...     return chain(iterable, repeat(None))
 
->>> def ncycles(seq, n):
-...     "Returns the sequence elements n times"
-...     return chain(*repeat(seq, n))
+>>> def ncycles(iterable, n):
+...     "Returns the seqeuence elements n times"
+...     return chain(*repeat(iterable, n))
 
 >>> def dotproduct(vec1, vec2):
 ...     return sum(map(operator.mul, vec1, vec2))
@@ -1302,9 +1282,24 @@
 
 >>> def compress(data, selectors):
 ...     "compress('abcdef', [1,0,1,0,1,1]) --> a c e f"
-...     for d, s in zip(data, selectors):
-...         if s:
-...             yield d
+...     decorated = zip(data, selectors)
+...     filtered =  filter(operator.itemgetter(1), decorated)
+...     return map(operator.itemgetter(0), filtered)
+
+>>> def combinations_with_replacement(iterable, r):
+...     "combinations_with_replacement('ABC', 3) --> AA AB AC BB BC CC"
+...     pool = tuple(iterable)
+...     n = len(pool)
+...     indices = [0] * r
+...     yield tuple(pool[i] for i in indices)
+...     while 1:
+...         for i in reversed(range(r)):
+...             if indices[i] != n - 1:
+...                 break
+...         else:
+...             return
+...         indices[i:] = [indices[i] + 1] * (r - i)
+...         yield tuple(pool[i] for i in indices)
 
 This is not part of the examples but it tests to make sure the definitions
 perform as purported.
@@ -1321,24 +1316,6 @@
 >>> nth('abcde', 3)
 ['d']
 
->>> all([2, 4, 6, 8], lambda x: x%2==0)
-True
-
->>> all([2, 3, 6, 8], lambda x: x%2==0)
-False
-
->>> any([2, 4, 6, 8], lambda x: x%2==0)
-True
-
->>> any([1, 3, 5, 9], lambda x: x%2==0,)
-False
-
->>> no([1, 3, 5, 9], lambda x: x%2==0)
-True
-
->>> no([1, 2, 5, 9], lambda x: x%2==0)
-False
-
 >>> quantify(range(99), lambda x: x%2==0)
 50
 
@@ -1383,6 +1360,9 @@
 >>> list(compress('abcdef', [1,0,1,0,1,1]))
 ['a', 'c', 'e', 'f']
 
+>>> list(combinations_with_replacement('abc', 2))
+[('a', 'a'), ('a', 'b'), ('a', 'c'), ('b', 'b'), ('b', 'c'), ('c', 'c')]
+
 """
 
 __test__ = {'libreftest' : libreftest}
diff --git a/Lib/test/test_locale.py b/Lib/test/test_locale.py
index 6d13058..b1ff14a 100644
--- a/Lib/test/test_locale.py
+++ b/Lib/test/test_locale.py
@@ -1,4 +1,4 @@
-from test.support import verbose, TestSkipped
+from test.support import verbose, TestSkipped, TestFailed
 import locale
 import sys
 
@@ -78,3 +78,12 @@
 
 finally:
     locale.setlocale(locale.LC_NUMERIC, oldlocale)
+
+if hasattr(locale, "strcoll"):
+    # test crasher from bug #3303
+    try:
+        locale.strcoll("a", None)
+    except TypeError:
+        pass
+    else:
+        raise TestFailed("TypeError not raised")
diff --git a/Lib/test/test_logging.py b/Lib/test/test_logging.py
index 888ac72..55502d6 100644
--- a/Lib/test/test_logging.py
+++ b/Lib/test/test_logging.py
@@ -584,6 +584,9 @@
     datefmt=
     """
 
+    # config5 specifies a custom handler class to be loaded
+    config5 = config1.replace('class=StreamHandler', 'class=logging.StreamHandler')
+
     def apply_config(self, conf):
         try:
             fn = tempfile.mktemp(".ini")
@@ -609,10 +612,10 @@
             # Original logger output is empty.
             self.assert_log_lines([])
 
-    def test_config1_ok(self):
+    def test_config1_ok(self, config=config1):
         # A config file defining a sub-parser as well.
         with captured_stdout() as output:
-            self.apply_config(self.config1)
+            self.apply_config(config)
             logger = logging.getLogger("compiler.parser")
             # Both will output a message
             logger.info(self.next_message())
@@ -647,6 +650,8 @@
             # Original logger output is empty
             self.assert_log_lines([])
 
+    def test_config5_ok(self):
+        self.test_config1_ok(config=self.config5)
 
 class LogRecordStreamHandler(StreamRequestHandler):
 
diff --git a/Lib/test/test_multibytecodec.py b/Lib/test/test_multibytecodec.py
index 0eb422e..7962d5e 100644
--- a/Lib/test/test_multibytecodec.py
+++ b/Lib/test/test_multibytecodec.py
@@ -8,6 +8,7 @@
 from test import test_multibytecodec_support
 from test.support import TESTFN
 import unittest, io, codecs, sys, os
+import _multibytecodec
 
 ALL_CJKENCODINGS = [
 # _codecs_cn
@@ -53,6 +54,14 @@
         finally:
             support.unlink(TESTFN)
 
+    def test_init_segfault(self):
+        # bug #3305: this used to segfault
+        self.assertRaises(AttributeError,
+                          _multibytecodec.MultibyteStreamReader, None)
+        self.assertRaises(AttributeError,
+                          _multibytecodec.MultibyteStreamWriter, None)
+
+
 class Test_IncrementalEncoder(unittest.TestCase):
 
     def test_stateless(self):
diff --git a/Lib/test/test_multiprocessing.py b/Lib/test/test_multiprocessing.py
index 5f5c588..2841424 100644
--- a/Lib/test/test_multiprocessing.py
+++ b/Lib/test/test_multiprocessing.py
@@ -1038,7 +1038,7 @@
         gc.collect()                       # do garbage collection
         refs = self.manager._number_of_objects()
         if refs != EXPECTED_NUMBER:
-            print(self.manager._debugInfo())
+            print(self.manager._debug_info())
 
         self.assertEqual(refs, EXPECTED_NUMBER)
 
diff --git a/Lib/test/test_random.py b/Lib/test/test_random.py
index 04c49fa..da62a4f 100644
--- a/Lib/test/test_random.py
+++ b/Lib/test/test_random.py
@@ -5,7 +5,7 @@
 import time
 import pickle
 import warnings
-from math import log, exp, sqrt, pi
+from math import log, exp, sqrt, pi, sum as msum
 from test import support
 
 class TestBasicOps(unittest.TestCase):
@@ -389,11 +389,9 @@
 
 def gamma(z, cof=_gammacoeff, g=7):
     z -= 1.0
-    sum = cof[0]
-    for i in range(1,len(cof)):
-        sum += cof[i] / (z+i)
+    s = msum([cof[0]] + [cof[i] / (z+i) for i in range(1,len(cof))])
     z += 0.5
-    return (z+g)**z / exp(z+g) * sqrt(2*pi) * sum
+    return (z+g)**z / exp(z+g) * sqrt(2.0*pi) * s
 
 class TestDistributions(unittest.TestCase):
     def test_zeroinputs(self):
diff --git a/Lib/test/test_robotparser.py b/Lib/test/test_robotparser.py
index f02f986..2101918 100644
--- a/Lib/test/test_robotparser.py
+++ b/Lib/test/test_robotparser.py
@@ -139,7 +139,8 @@
 class NetworkTestCase(unittest.TestCase):
 
     def testPasswordProtectedSite(self):
-        support.requires('network')
+        if not support.is_resource_enabled('network'):
+            return
         # whole site is password-protected.
         url = 'http://mueblesmoraleda.com'
         parser = urllib.robotparser.RobotFileParser()
@@ -148,7 +149,8 @@
         self.assertEqual(parser.can_fetch("*", url+"/robots.txt"), False)
 
     def testPythonOrg(self):
-        support.requires('network')
+        if not support.is_resource_enabled('network'):
+            return
         parser = urllib.robotparser.RobotFileParser(
             "http://www.python.org/robots.txt")
         parser.read()
@@ -160,5 +162,5 @@
     support.run_unittest(tests)
 
 if __name__=='__main__':
-    support.Verbose = 1
+    support.verbose = 1
     test_main()
diff --git a/Lib/test/test_scope.py b/Lib/test/test_scope.py
index a3f1d4a..65d87cf 100644
--- a/Lib/test/test_scope.py
+++ b/Lib/test/test_scope.py
@@ -495,6 +495,24 @@
         self.assert_("x" not in varnames)
         self.assert_("y" in varnames)
 
+    def testLocalsClass_WithTrace(self):
+        # Issue23728: after the trace function returns, the locals()
+        # dictionary is used to update all variables, this used to
+        # include free variables. But in class statements, free
+        # variables are not inserted...
+        import sys
+        sys.settrace(lambda a,b,c:None)
+        try:
+            x = 12
+
+            class C:
+                def f(self):
+                    return x
+
+            self.assertEquals(x, 12) # Used to raise UnboundLocalError
+        finally:
+            sys.settrace(None)
+
     def testBoundAndFree(self):
         # var is bound and free in class
 
diff --git a/Modules/_localemodule.c b/Modules/_localemodule.c
index 37b7ec1..8441f1e 100644
--- a/Modules/_localemodule.c
+++ b/Modules/_localemodule.c
@@ -530,7 +530,7 @@
 PyIntl_gettext(PyObject* self, PyObject *args)
 {
 	char *in;
-	if (!PyArg_ParseTuple(args, "z", &in))
+	if (!PyArg_ParseTuple(args, "s", &in))
 		return 0;
 	return str2uni(gettext(in));
 }
@@ -543,7 +543,7 @@
 PyIntl_dgettext(PyObject* self, PyObject *args)
 {
 	char *domain, *in;
-	if (!PyArg_ParseTuple(args, "zz", &domain, &in))
+	if (!PyArg_ParseTuple(args, "zs", &domain, &in))
 		return 0;
 	return str2uni(dgettext(domain, in));
 }
@@ -557,7 +557,7 @@
 {
 	char *domain, *msgid;
 	int category;
-	if (!PyArg_ParseTuple(args, "zzi", &domain, &msgid, &category))
+	if (!PyArg_ParseTuple(args, "zsi", &domain, &msgid, &category))
 		return 0;
 	return str2uni(dcgettext(domain,msgid,category));
 }
@@ -587,9 +587,13 @@
 static PyObject*
 PyIntl_bindtextdomain(PyObject* self,PyObject*args)
 {
-	char *domain,*dirname;
-	if (!PyArg_ParseTuple(args, "zz", &domain, &dirname))
+	char *domain, *dirname;
+	if (!PyArg_ParseTuple(args, "sz", &domain, &dirname))
 		return 0;
+	if (!strlen(domain)) {
+		PyErr_SetString(Error, "domain must be a non-empty string");
+		return 0;
+	}
 	dirname = bindtextdomain(domain, dirname);
 	if (!dirname) {
 		PyErr_SetFromErrno(PyExc_OSError);
diff --git a/Modules/_sqlite/connection.c b/Modules/_sqlite/connection.c
index b2cca80..1e52918 100644
--- a/Modules/_sqlite/connection.c
+++ b/Modules/_sqlite/connection.c
@@ -902,8 +902,13 @@
         }
 
         statement = PyUnicode_AsStringAndSize(begin_statement, &size);
+        if (!statement) {
+            Py_DECREF(statement);
+            return -1;
+        }
         self->begin_statement = PyMem_Malloc(size + 2);
         if (!self->begin_statement) {
+            Py_DECREF(begin_statement);
             return -1;
         }
 
diff --git a/Modules/_sqlite/module.c b/Modules/_sqlite/module.c
index 3f209eb..084eac1 100644
--- a/Modules/_sqlite/module.c
+++ b/Modules/_sqlite/module.c
@@ -147,6 +147,7 @@
 {
     PyTypeObject* type;
     PyObject* caster;
+    int rc;
 
     if (!PyArg_ParseTuple(args, "OO", &type, &caster)) {
         return NULL;
@@ -159,7 +160,9 @@
         pysqlite_BaseTypeAdapted = 1;
     }
 
-    microprotocols_add(type, (PyObject*)&pysqlite_PrepareProtocolType, caster);
+    rc = microprotocols_add(type, (PyObject*)&pysqlite_PrepareProtocolType, caster);
+    if (rc == -1)
+        return NULL;
 
     Py_INCREF(Py_None);
     return Py_None;
diff --git a/Modules/cjkcodecs/multibytecodec.c b/Modules/cjkcodecs/multibytecodec.c
index d6bafe7..e65a9a4 100644
--- a/Modules/cjkcodecs/multibytecodec.c
+++ b/Modules/cjkcodecs/multibytecodec.c
@@ -1502,7 +1502,7 @@
 {
 	PyObject_GC_UnTrack(self);
 	ERROR_DECREF(self->errors);
-	Py_DECREF(self->stream);
+	Py_XDECREF(self->stream);
 	Py_TYPE(self)->tp_free(self);
 }
 
@@ -1705,7 +1705,7 @@
 {
 	PyObject_GC_UnTrack(self);
 	ERROR_DECREF(self->errors);
-	Py_DECREF(self->stream);
+	Py_XDECREF(self->stream);
 	Py_TYPE(self)->tp_free(self);
 }
 
diff --git a/Modules/posixmodule.c b/Modules/posixmodule.c
index bc17b6b..4cdaf25 100644
--- a/Modules/posixmodule.c
+++ b/Modules/posixmodule.c
@@ -2350,11 +2350,19 @@
 		return NULL;
 	}
 	for (;;) {
+		errno = 0;
 		Py_BEGIN_ALLOW_THREADS
 		ep = readdir(dirp);
 		Py_END_ALLOW_THREADS
-		if (ep == NULL)
-			break;
+		if (ep == NULL) {
+			if (errno == 0) {
+				break;
+			} else {
+				closedir(dirp);
+				Py_DECREF(d);
+				return posix_error_with_allocated_filename(name);
+			}
+		}
 		if (ep->d_name[0] == '.' &&
 		    (NAMLEN(ep) == 1 ||
 		     (ep->d_name[1] == '.' && NAMLEN(ep) == 2)))
@@ -2389,12 +2397,6 @@
 		}
 		Py_DECREF(v);
 	}
-	if (errno != 0 && d != NULL) {
-		/* readdir() returned NULL and set errno */
-		closedir(dirp);
-		Py_DECREF(d);
-		return posix_error_with_allocated_filename(name); 
-	}
 	closedir(dirp);
 	PyMem_Free(name);
 
diff --git a/Objects/bytearrayobject.c b/Objects/bytearrayobject.c
index 0d256b9..a76f827 100644
--- a/Objects/bytearrayobject.c
+++ b/Objects/bytearrayobject.c
@@ -447,7 +447,7 @@
     else {
             if (_getbuffer(values, &vbytes) < 0) {
                     PyErr_Format(PyExc_TypeError,
-                                 "can't set bytes slice from %.100s",
+                                 "can't set bytearray slice from %.100s",
                                  Py_TYPE(values)->tp_name);
                     return -1;
             }
@@ -699,7 +699,7 @@
     }
 
     /* Parse arguments */
-    if (!PyArg_ParseTupleAndKeywords(args, kwds, "|Oss:bytes", kwlist,
+    if (!PyArg_ParseTupleAndKeywords(args, kwds, "|Oss:bytearray", kwlist,
                                      &arg, &encoding, &errors))
         return -1;
 
diff --git a/Objects/frameobject.c b/Objects/frameobject.c
index 035c2c5..01fb565 100644
--- a/Objects/frameobject.c
+++ b/Objects/frameobject.c
@@ -909,9 +909,12 @@
 	if (ncells || nfreevars) {
 		dict_to_map(co->co_cellvars, ncells,
 			    locals, fast + co->co_nlocals, 1, clear);
-		dict_to_map(co->co_freevars, nfreevars,
-			    locals, fast + co->co_nlocals + ncells, 1, 
-			    clear);
+		/* Same test as in PyFrame_FastToLocals() above. */
+		if (co->co_flags & CO_OPTIMIZED) {
+			dict_to_map(co->co_freevars, nfreevars,
+			        locals, fast + co->co_nlocals + ncells, 1, 
+			        clear);
+		}
 	}
 	PyErr_Restore(error_type, error_value, error_traceback);
 }
diff --git a/PC/_subprocess.c b/PC/_subprocess.c
index 77a8a85..8c9a352 100644
--- a/PC/_subprocess.c
+++ b/PC/_subprocess.c
@@ -66,6 +66,14 @@
 	return (PyObject*) self;
 }
 
+#if defined(MS_WIN32) && !defined(MS_WIN64)
+#define HANDLE_TO_PYNUM(handle)	PyLong_FromLong((long) handle)
+#define PY_HANDLE_PARAM	"l"
+#else
+#define HANDLE_TO_PYNUM(handle)	PyLong_FromLongLong((long long) handle)
+#define PY_HANDLE_PARAM	"L"
+#endif
+
 static PyObject*
 sp_handle_detach(sp_handle_object* self, PyObject* args)
 {
@@ -79,7 +87,7 @@
 	self->handle = NULL;
 
 	/* note: return the current handle, as an integer */
-	return PyLong_FromLong((long) handle);
+	return HANDLE_TO_PYNUM(handle);
 }
 
 static PyObject*
@@ -113,7 +121,7 @@
 static PyObject*
 sp_handle_as_int(sp_handle_object* self)
 {
-	return PyLong_FromLong((long) self->handle);
+	return HANDLE_TO_PYNUM(self->handle);
 }
 
 static PyNumberMethods sp_handle_as_number;
@@ -172,7 +180,7 @@
 	}
 
 	/* note: returns integer, not handle object */
-	return PyLong_FromLong((long) handle);
+	return HANDLE_TO_PYNUM(handle);
 }
 
 static PyObject *
@@ -190,14 +198,16 @@
 	HANDLE target_handle;
 	BOOL result;
 
-	long source_process_handle;
-	long source_handle;
-	long target_process_handle;
+	HANDLE source_process_handle;
+	HANDLE source_handle;
+	HANDLE target_process_handle;
 	int desired_access;
 	int inherit_handle;
 	int options = 0;
 
-	if (! PyArg_ParseTuple(args, "lllii|i:DuplicateHandle",
+	if (! PyArg_ParseTuple(args,
+			       PY_HANDLE_PARAM PY_HANDLE_PARAM PY_HANDLE_PARAM
+			       "ii|i:DuplicateHandle",
 	                       &source_process_handle,
 	                       &source_handle,
 	                       &target_process_handle,
@@ -208,9 +218,9 @@
 
 	Py_BEGIN_ALLOW_THREADS
 	result = DuplicateHandle(
-		(HANDLE) source_process_handle,
-		(HANDLE) source_handle,
-		(HANDLE) target_process_handle,
+		source_process_handle,
+		source_handle,
+		target_process_handle,
 		&target_handle,
 		desired_access,
 		inherit_handle,
@@ -440,13 +450,13 @@
 {
 	BOOL result;
 
-	long process;
+	HANDLE process;
 	int exit_code;
-	if (! PyArg_ParseTuple(args, "li:TerminateProcess", &process,
-			       &exit_code))
+	if (! PyArg_ParseTuple(args, PY_HANDLE_PARAM "i:TerminateProcess",
+			       &process, &exit_code))
 		return NULL;
 
-	result = TerminateProcess((HANDLE) process, exit_code);
+	result = TerminateProcess(process, exit_code);
 
 	if (! result)
 		return PyErr_SetFromWindowsErr(GetLastError());
@@ -461,11 +471,11 @@
 	DWORD exit_code;
 	BOOL result;
 
-	long process;
-	if (! PyArg_ParseTuple(args, "l:GetExitCodeProcess", &process))
+	HANDLE process;
+	if (! PyArg_ParseTuple(args, PY_HANDLE_PARAM ":GetExitCodeProcess", &process))
 		return NULL;
 
-	result = GetExitCodeProcess((HANDLE) process, &exit_code);
+	result = GetExitCodeProcess(process, &exit_code);
 
 	if (! result)
 		return PyErr_SetFromWindowsErr(GetLastError());
@@ -478,15 +488,15 @@
 {
 	DWORD result;
 
-	long handle;
+	HANDLE handle;
 	int milliseconds;
-	if (! PyArg_ParseTuple(args, "li:WaitForSingleObject",
+	if (! PyArg_ParseTuple(args, PY_HANDLE_PARAM "i:WaitForSingleObject",
 	                  	     &handle,
 	                  	     &milliseconds))
 		return NULL;
 
 	Py_BEGIN_ALLOW_THREADS
-	result = WaitForSingleObject((HANDLE) handle, (DWORD) milliseconds);
+	result = WaitForSingleObject(handle, (DWORD) milliseconds);
 	Py_END_ALLOW_THREADS
 
 	if (result == WAIT_FAILED)
@@ -508,13 +518,14 @@
 sp_GetModuleFileName(PyObject* self, PyObject* args)
 {
 	BOOL result;
-	long module;
+	HMODULE module;
 	WCHAR filename[MAX_PATH];
 
-	if (! PyArg_ParseTuple(args, "l:GetModuleFileName", &module))
+	if (! PyArg_ParseTuple(args, PY_HANDLE_PARAM ":GetModuleFileName",
+			       &module))
 		return NULL;
 
-	result = GetModuleFileNameW((HMODULE)module, filename, MAX_PATH);
+	result = GetModuleFileNameW(module, filename, MAX_PATH);
 	filename[MAX_PATH-1] = '\0';
 
 	if (! result)
diff --git a/Python/pythonrun.c b/Python/pythonrun.c
index 3a6cc91..2ab1d46 100644
--- a/Python/pythonrun.c
+++ b/Python/pythonrun.c
@@ -1778,10 +1778,10 @@
 	case E_INTR:
 		if (!PyErr_Occurred())
 			PyErr_SetNone(PyExc_KeyboardInterrupt);
-		return;
+		goto cleanup;
 	case E_NOMEM:
 		PyErr_NoMemory();
-		return;
+		goto cleanup;
 	case E_EOF:
 		msg = "unexpected EOF while parsing";
 		break;
@@ -1839,10 +1839,6 @@
 	}
 	v = Py_BuildValue("(ziiN)", err->filename,
 			  err->lineno, err->offset, errtext);
-	if (err->text != NULL) {
-		PyObject_FREE(err->text);
-		err->text = NULL;
-	}
 	w = NULL;
 	if (v != NULL)
 		w = Py_BuildValue("(sO)", msg, v);
@@ -1850,6 +1846,11 @@
 	Py_XDECREF(v);
 	PyErr_SetObject(errtype, w);
 	Py_XDECREF(w);
+cleanup:
+	if (err->text != NULL) {
+		PyObject_FREE(err->text);
+		err->text = NULL;
+	}
 }
 
 /* Print fatal error message and abort */
diff --git a/configure b/configure
index 7020f73..51fa040 100755
--- a/configure
+++ b/configure
@@ -4612,7 +4612,7 @@
 
 
 		BASECFLAGS="${UNIVERSAL_ARCH_FLAGS} -isysroot ${UNIVERSALSDK} ${BASECFLAGS}"
-		tgt=`sw_vers -productVersion | sed 's/\(10\.0-9*\).*/\1/'`
+		tgt=`sw_vers -productVersion | sed 's/\(10\.[0-9]*\).*/\1/'`
 		if test "${UNIVERSALSDK}" != "/" -a "${tgt}" '>' '10.4' ; then
 			CFLAGS="${UNIVERSAL_ARCH_FLAGS} -isysroot ${UNIVERSALSDK} ${CFLAGS}"
 		fi
diff --git a/configure.in b/configure.in
index 322d52b..870b8a9 100644
--- a/configure.in
+++ b/configure.in
@@ -880,7 +880,7 @@
 
 
 		BASECFLAGS="${UNIVERSAL_ARCH_FLAGS} -isysroot ${UNIVERSALSDK} ${BASECFLAGS}"
-		tgt=`sw_vers -productVersion | sed 's/\(10\.[0-9]*\).*/\1/'`
+		tgt=`sw_vers -productVersion | sed 's/\(10\.[[0-9]]*\).*/\1/'`
 		if test "${UNIVERSALSDK}" != "/" -a "${tgt}" '>' '10.4' ; then
 			CFLAGS="${UNIVERSAL_ARCH_FLAGS} -isysroot ${UNIVERSALSDK} ${CFLAGS}"
 		fi