diff --git a/Doc/README.txt b/Doc/README.txt
index a93542f..202a1ce 100644
--- a/Doc/README.txt
+++ b/Doc/README.txt
@@ -14,7 +14,7 @@
 Building the docs
 =================
 
-You need to install Python 2.5.1 or higher (but Python 3.0 is not supported yet);
+You need to install Python 2.4 or higher (but Python 3.0 is not supported yet);
 the toolset used to build the docs are written in Python.  The toolset used
 to build the documentation is called *Sphinx*, it is not included in this
 tree, but maintained separately in the Python Subversion repository.  Also
@@ -55,7 +55,7 @@
 
  * "latex", which builds LaTeX source files that can be run with "pdflatex"
    to produce PDF documents.
- 
+
  * "linkcheck", which checks all external references to see whether they are
    broken, redirected or malformed, and outputs this information to stdout
    as well as a plain-text (.txt) file.
diff --git a/Doc/conf.py b/Doc/conf.py
index 273c76c..1c8dd71 100644
--- a/Doc/conf.py
+++ b/Doc/conf.py
@@ -38,17 +38,17 @@
 today_fmt = '%B %d, %Y'
 
 # List of files that shouldn't be included in the build.
-unused_files = [
-    'whatsnew/2.0.rst',
-    'whatsnew/2.1.rst',
-    'whatsnew/2.2.rst',
-    'whatsnew/2.3.rst',
-    'whatsnew/2.4.rst',
-    'whatsnew/2.5.rst',
-    'whatsnew/2.6.rst',
-    'maclib/scrap.rst',
-    'library/xmllib.rst',
-    'library/xml.etree.rst',
+unused_docs = [
+    'whatsnew/2.0',
+    'whatsnew/2.1',
+    'whatsnew/2.2',
+    'whatsnew/2.3',
+    'whatsnew/2.4',
+    'whatsnew/2.5',
+    'whatsnew/2.6',
+    'maclib/scrap',
+    'library/xmllib',
+    'library/xml.etree',
 ]
 
 # Relative filename of the reference count data file.
diff --git a/Doc/extending/windows.rst b/Doc/extending/windows.rst
index a34ba2b..a0782a7 100644
--- a/Doc/extending/windows.rst
+++ b/Doc/extending/windows.rst
@@ -179,7 +179,7 @@
 
    MyObject_Type.ob_type = &PyType_Type;
 
-Refer to section 3 of the `Python FAQ <http://www.python.org/doc/FAQ.html>`_ for
+Refer to section 3 of the `Python FAQ <http://www.python.org/doc/faq>`_ for
 details on why you must do this.
 
 
diff --git a/Doc/library/decimal.rst b/Doc/library/decimal.rst
index f6b96b2..422436f 100644
--- a/Doc/library/decimal.rst
+++ b/Doc/library/decimal.rst
@@ -1,6 +1,6 @@
 
-:mod:`decimal` --- Decimal floating point arithmetic
-====================================================
+:mod:`decimal` --- Decimal fixed point and floating point arithmetic
+====================================================================
 
 .. module:: decimal
    :synopsis: Implementation of the General Decimal Arithmetic  Specification.
@@ -16,6 +16,11 @@
 The :mod:`decimal` module provides support for decimal floating point
 arithmetic.  It offers several advantages over the :class:`float` datatype:
 
+* Decimal "is based on a floating-point model which was designed with people
+  in mind, and necessarily has a paramount guiding principle -- computers must
+  provide an arithmetic that works in the same way as the arithmetic that
+  people learn at school." -- excerpt from the decimal arithmetic specification.
+
 * Decimal numbers can be represented exactly.  In contrast, numbers like
   :const:`1.1` do not have an exact representation in binary floating point. End
   users typically would not expect :const:`1.1` to display as
@@ -25,7 +30,7 @@
   + 0.1 + 0.1 - 0.3`` is exactly equal to zero.  In binary floating point, the result
   is :const:`5.5511151231257827e-017`.  While near to zero, the differences
   prevent reliable equality testing and differences can accumulate. For this
-  reason, decimal would be preferred in accounting applications which have strict
+  reason, decimal is preferred in accounting applications which have strict
   equality invariants.
 
 * The decimal module incorporates a notion of significant places so that ``1.30
@@ -50,6 +55,13 @@
   standards.  While the built-in float type exposes only a modest portion of its
   capabilities, the decimal module exposes all required parts of the standard.
   When needed, the programmer has full control over rounding and signal handling.
+  This includes an option to enforce exact arithmetic by using exceptions
+  to block any inexact operations.
+
+* The decimal module was designed to support "without prejudice, both exact
+  unrounded decimal arithmetic (sometimes called fixed-point arithmetic)
+  and rounded floating-point arithmetic."  -- excerpt from the decimal
+  arithmetic specification.
 
 The module design is centered around three concepts:  the decimal number, the
 context for arithmetic, and signals.
@@ -832,7 +844,7 @@
    :const:`ROUND_HALF_EVEN`.  All flags are cleared.  No traps are enabled (so that
    exceptions are not raised during computations).
 
-   Because the trapped are disabled, this context is useful for applications that
+   Because the traps are disabled, this context is useful for applications that
    prefer to have result value of :const:`NaN` or :const:`Infinity` instead of
    raising exceptions.  This allows an application to complete a run in the
    presence of conditions that would otherwise halt the program.
@@ -1245,7 +1257,7 @@
 :const:`True`.  An attempt to compare two Decimals using any of the ``<``,
 ``<=``, ``>`` or ``>=`` operators will raise the :exc:`InvalidOperation` signal
 if either operand is a :const:`NaN`, and return :const:`False` if this signal is
-trapped.  Note that the General Decimal Arithmetic specification does not
+not trapped.  Note that the General Decimal Arithmetic specification does not
 specify the behavior of direct comparisons; these rules for comparisons
 involving a :const:`NaN` were taken from the IEEE 854 standard (see Table 3 in
 section 5.7).  To ensure strict standards-compliance, use the :meth:`compare`
diff --git a/Doc/library/rational.rst b/Doc/library/fractions.rst
similarity index 62%
rename from Doc/library/rational.rst
rename to Doc/library/fractions.rst
index 8ed702f..5f30caf 100644
--- a/Doc/library/rational.rst
+++ b/Doc/library/fractions.rst
@@ -1,28 +1,28 @@
 
-:mod:`rational` --- Rational numbers
+:mod:`fractions` --- Rational numbers
 ====================================
 
-.. module:: rational
+.. module:: fractions
    :synopsis: Rational numbers.
 .. moduleauthor:: Jeffrey Yasskin <jyasskin at gmail.com>
 .. sectionauthor:: Jeffrey Yasskin <jyasskin at gmail.com>
 .. versionadded:: 2.6
 
 
-The :mod:`rational` module defines an immutable, infinite-precision
+The :mod:`fractions` module defines an immutable, infinite-precision
 Rational number class.
 
 
-.. class:: Rational(numerator=0, denominator=1)
-           Rational(other_rational)
-           Rational(string)
+.. class:: Fraction(numerator=0, denominator=1)
+           Fraction(other_fraction)
+           Fraction(string)
 
    The first version requires that *numerator* and *denominator* are
    instances of :class:`numbers.Integral` and returns a new
-   ``Rational`` representing ``numerator/denominator``. If
+   ``Fraction`` representing ``numerator/denominator``. If
    *denominator* is :const:`0`, raises a :exc:`ZeroDivisionError`. The
-   second version requires that *other_rational* is an instance of
-   :class:`numbers.Rational` and returns an instance of
+   second version requires that *other_fraction* is an instance of
+   :class:`numbers.Fraction` and returns an instance of
    :class:`Rational` with the same value. The third version expects a
    string of the form ``[-+]?[0-9]+(/[0-9]+)?``, optionally surrounded
    by spaces.
@@ -31,39 +31,39 @@
    :class:`numbers.Rational` and is immutable and hashable.
 
 
-.. method:: Rational.from_float(flt)
+.. method:: Fraction.from_float(flt)
 
-   This classmethod constructs a :class:`Rational` representing the
+   This classmethod constructs a :class:`Fraction` representing the
    exact value of *flt*, which must be a :class:`float`. Beware that
-   ``Rational.from_float(0.3)`` is not the same value as ``Rational(3,
+   ``Fraction.from_float(0.3)`` is not the same value as ``Rational(3,
    10)``
 
 
-.. method:: Rational.from_decimal(dec)
+.. method:: Fraction.from_decimal(dec)
 
-   This classmethod constructs a :class:`Rational` representing the
+   This classmethod constructs a :class:`Fraction` representing the
    exact value of *dec*, which must be a
    :class:`decimal.Decimal`.
 
 
-.. method:: Rational.__floor__()
+.. method:: Fraction.__floor__()
 
    Returns the greatest :class:`int` ``<= self``. Will be accessible
    through :func:`math.floor` in Py3k.
 
 
-.. method:: Rational.__ceil__()
+.. method:: Fraction.__ceil__()
 
    Returns the least :class:`int` ``>= self``. Will be accessible
    through :func:`math.ceil` in Py3k.
 
 
-.. method:: Rational.__round__()
-            Rational.__round__(ndigits)
+.. method:: Fraction.__round__()
+            Fraction.__round__(ndigits)
 
    The first version returns the nearest :class:`int` to ``self``,
    rounding half to even. The second version rounds ``self`` to the
-   nearest multiple of ``Rational(1, 10**ndigits)`` (logically, if
+   nearest multiple of ``Fraction(1, 10**ndigits)`` (logically, if
    ``ndigits`` is negative), again rounding half toward even. Will be
    accessible through :func:`round` in Py3k.
 
diff --git a/Doc/library/numbers.rst b/Doc/library/numbers.rst
index 1d543c8..d78595e 100644
--- a/Doc/library/numbers.rst
+++ b/Doc/library/numbers.rst
@@ -104,7 +104,7 @@
 
 Implementors should be careful to make equal numbers equal and hash
 them to the same values. This may be subtle if there are two different
-extensions of the real numbers. For example, :class:`rational.Rational`
+extensions of the real numbers. For example, :class:`fractions.Fraction`
 implements :func:`hash` as follows::
 
     def __hash__(self):
@@ -199,11 +199,11 @@
 Because most of the operations on any given type will be very similar,
 it can be useful to define a helper function which generates the
 forward and reverse instances of any given operator. For example,
-:class:`rational.Rational` uses::
+:class:`fractions.Fraction` uses::
 
     def _operator_fallbacks(monomorphic_operator, fallback_operator):
         def forward(a, b):
-            if isinstance(b, (int, long, Rational)):
+            if isinstance(b, (int, long, Fraction)):
                 return monomorphic_operator(a, b)
             elif isinstance(b, float):
                 return fallback_operator(float(a), b)
@@ -215,7 +215,7 @@
         forward.__doc__ = monomorphic_operator.__doc__
 
         def reverse(b, a):
-            if isinstance(a, RationalAbc):
+            if isinstance(a, Rational):
                 # Includes ints.
                 return monomorphic_operator(a, b)
             elif isinstance(a, numbers.Real):
@@ -231,7 +231,7 @@
 
     def _add(a, b):
         """a + b"""
-        return Rational(a.numerator * b.denominator +
+        return Fraction(a.numerator * b.denominator +
                         b.numerator * a.denominator,
                         a.denominator * b.denominator)
 
diff --git a/Doc/library/pickletools.rst b/Doc/library/pickletools.rst
index 3fc38ff..3dc06ac 100644
--- a/Doc/library/pickletools.rst
+++ b/Doc/library/pickletools.rst
@@ -33,3 +33,10 @@
    the opcode's argument; *pos* is the position at which this opcode is located.
    *pickle* can be a string or a file-like object.
 
+.. function:: optimize(picklestring)
+
+   Returns a new equivalent pickle string after eliminating unused ``PUT``
+   opcodes. The optimized pickle is shorter, takes less transmission time,
+   requires less storage space, and unpickles more efficiently.
+
+   .. versionadded:: 2.6
diff --git a/Doc/whatsnew/2.6.rst b/Doc/whatsnew/2.6.rst
index cbc8b8f..d37c5ac 100644
--- a/Doc/whatsnew/2.6.rst
+++ b/Doc/whatsnew/2.6.rst
@@ -578,8 +578,8 @@
 
 :class:`Rational` numbers derive from :class:`Real`, have
 :attr:`numerator` and :attr:`denominator` properties, and can be
-converted to floats.  Python 2.6 adds a simple rational-number class
-in the :mod:`rational` module.
+converted to floats.  Python 2.6 adds a simple rational-number class,
+:class:`Fraction`, in the :mod:`fractions` module.
 
 :class:`Integral` numbers derive from :class:`Rational`, and
 can be shifted left and right with ``<<`` and ``>>``, 
@@ -598,29 +598,29 @@
 
   
 
-The Rational Module
+The Fraction Module
 --------------------------------------------------
 
 To fill out the hierarchy of numeric types, a rational-number class
-has been added as the :mod:`rational` module.  Rational numbers are
+has been added as the :mod:`fractions` module.  Rational numbers are
 represented as a fraction; rational numbers can exactly represent
 numbers such as two-thirds that floating-point numbers can only
 approximate.
 
-The :class:`Rational` constructor takes two :class:`Integral` values
+The :class:`Fraction` constructor takes two :class:`Integral` values
 that will be the numerator and denominator of the resulting fraction. ::
 
-    >>> from rational import Rational
-    >>> a = Rational(2, 3)
-    >>> b = Rational(2, 5)
+    >>> from fractions import Fraction
+    >>> a = Fraction(2, 3)
+    >>> b = Fraction(2, 5)
     >>> float(a), float(b)
     (0.66666666666666663, 0.40000000000000002)
     >>> a+b
-    rational.Rational(16,15)
+    Fraction(16, 15)
     >>> a/b
-    rational.Rational(5,3)
+    Fraction(5, 3)
 
-The :mod:`rational` module is based upon an implementation by Sjoerd
+The :mod:`fractions` module is based upon an implementation by Sjoerd
 Mullender that was in Python's :file:`Demo/classes/` directory for a
 long time.  This implementation was significantly updated by Jeffrey
 Yaskin.