diff --git a/Doc/bugs.rst b/Doc/bugs.rst
index 9977abda2f6..9c6e5247292 100644
--- a/Doc/bugs.rst
+++ b/Doc/bugs.rst
@@ -8,11 +8,7 @@ Python is a mature programming language which has established a reputation for
 stability.  In order to maintain this reputation, the developers would like to
 know of any deficiencies you find in Python.
 
-If you find errors in the documentation, please use either the "Add a comment"
-or the "Suggest a change" features of the relevant page in the most recent
-online documentation at http://docs.python.org/.
-
-All other bug reports should be submitted via the Python Bug Tracker
+Bug reports should be submitted via the Python Bug Tracker
 (http://bugs.python.org/).  The bug tracker offers a Web form which allows
 pertinent information to be entered and submitted to the developers.
 
diff --git a/Doc/library/multiprocessing.rst b/Doc/library/multiprocessing.rst
index 4bbd94c385a..a247e2f16db 100644
--- a/Doc/library/multiprocessing.rst
+++ b/Doc/library/multiprocessing.rst
@@ -248,7 +248,7 @@ The :mod:`multiprocessing` package mostly replicates the API of the
 
    The constructor should always be called with keyword arguments. *group*
    should always be ``None``; it exists solely for compatibility with
-   :class:`~threading.Thread`.  *target* is the callable object to be invoked by
+   :class:`threading.Thread`.  *target* is the callable object to be invoked by
    the :meth:`run()` method.  It defaults to ``None``, meaning nothing is
    called. *name* is the process name.  By default, a unique name is constructed
    of the form 'Process-N\ :sub:`1`:N\ :sub:`2`:...:N\ :sub:`k`' where N\
@@ -290,13 +290,9 @@ The :mod:`multiprocessing` package mostly replicates the API of the
       A process cannot join itself because this would cause a deadlock.  It is
       an error to attempt to join a process before it has been started.
 
-   .. attribute:: Process.name
+   .. attribute:: name
 
-      Return the process's name.
-
-   .. attribute:: Process.name = name
-
-      Set the process's name.
+      The process's name.
 
       The name is a string used for identification purposes only.  It has no
       semantics.  Multiple processes may be given the same name.  The initial
@@ -309,14 +305,10 @@ The :mod:`multiprocessing` package mostly replicates the API of the
       Roughly, a process object is alive from the moment the :meth:`start`
       method returns until the child process terminates.
 
-   .. attribute:: Process.daemon
+   .. attribute:: daemon
 
-      Return the process's daemon flag., this is a boolean.
-
-   .. attribute:: Process.daemon = daemonic
-
-      Set the process's daemon flag to the Boolean value *daemonic*.  This must
-      be called before :meth:`start` is called.
+      The process's daemon flag, a Boolean value.  This must be called before
+      :meth:`start` is called.
 
       The initial value is inherited from the creating process.
 
@@ -327,36 +319,33 @@ The :mod:`multiprocessing` package mostly replicates the API of the
       Otherwise a daemonic process would leave its children orphaned if it gets
       terminated when its parent process exits.
 
-   In addition process objects also support the following methods:
+   In addition to the  :class:`Threading.Thread` API, :class:`Process` objects
+   also support the following attributes and methods:
 
-   .. attribute:: Process.pid
+   .. attribute:: pid
 
       Return the process ID.  Before the process is spawned, this will be
       ``None``.
 
-   .. attribute:: Process.exitcode
+   .. attribute:: exitcode
 
-      Return the child's exit code.  This will be ``None`` if the process has
-      not yet terminated.  A negative value *-N* indicates that the child was
-      terminated by signal *N*.
+      The child's exit code.  This will be ``None`` if the process has not yet
+      terminated.  A negative value *-N* indicates that the child was terminated
+      by signal *N*.
 
-   .. attribute:: Process.authkey
+   .. attribute:: authkey
 
-      Return the process's authentication key (a byte string).
+      The process's authentication key (a byte string).
 
       When :mod:`multiprocessing` is initialized the main process is assigned a
       random string using :func:`os.random`.
 
       When a :class:`Process` object is created, it will inherit the
-      authentication key of its parent process, although this may be changed
-      using :attr:`Process.authkey` below.
+      authentication key of its parent process, although this may be changed by
+      setting :attr:`authkey` to another byte string.
 
       See :ref:`multiprocessing-auth-keys`.
 
-   .. attribute:: Process.authkey = authkey
-
-      Set the process's authentication key which must be a byte string.
-
    .. method:: terminate()
 
       Terminate the process.  On Unix this is done using the ``SIGTERM`` signal;
@@ -375,8 +364,8 @@ The :mod:`multiprocessing` package mostly replicates the API of the
          cause other processes to deadlock.
 
    Note that the :meth:`start`, :meth:`join`, :meth:`is_alive` and
-   :meth:`get_exit_code` methods should only be called by the process that
-   created the process object.
+   :attr:`exit_code` methods should only be called by the process that created
+   the process object.
 
    Example usage of some of the methods of :class:`Process`::
 
@@ -390,7 +379,7 @@ The :mod:`multiprocessing` package mostly replicates the API of the
        >>> p.terminate()
        >>> print p, p.is_alive()
        <Process(Process-1, stopped[SIGTERM])> False
-       >>> p.get_exit_code() == -signal.SIGTERM
+       >>> p.exitcode == -signal.SIGTERM
        True
 
 
@@ -1075,7 +1064,7 @@ their parent process exits.  The manager classes are defined in the
 
    *authkey* is the authentication key which will be used to check the validity
    of incoming connections to the server process.  If *authkey* is ``None`` then
-   ``current_process().get_auth_key()``.  Otherwise *authkey* is used and it
+   ``current_process().authkey``.  Otherwise *authkey* is used and it
    must be a string.
 
    .. method:: start()
@@ -1599,7 +1588,7 @@ authentication* using the :mod:`hmac` module.
 
    If *authentication* is ``True`` or *authkey* is a string then digest
    authentication is used.  The key used for authentication will be either
-   *authkey* or ``current_process().get_auth_key()`` if *authkey* is ``None``.
+   *authkey* or ``current_process().authkey)`` if *authkey* is ``None``.
    If authentication fails then :exc:`AuthenticationError` is raised.  See
    :ref:`multiprocessing-auth-keys`.
 
@@ -1632,7 +1621,7 @@ authentication* using the :mod:`hmac` module.
    otherwise it must be *None*.
 
    If *authkey* is ``None`` and *authenticate* is ``True`` then
-   ``current_process().get_auth_key()`` is used as the authentication key.  If
+   ``current_process().authkey`` is used as the authentication key.  If
    *authkey* is ``None`` and *authentication* is ``False`` then no
    authentication is done.  If authentication fails then
    :exc:`AuthenticationError` is raised.  See :ref:`multiprocessing-auth-keys`.
@@ -1748,7 +1737,7 @@ authentication key.  (Demonstrating that both ends are using the same key does
 **not** involve sending the key over the connection.)
 
 If authentication is requested but do authentication key is specified then the
-return value of ``current_process().get_auth_key`` is used (see
+return value of ``current_process().authkey`` is used (see
 :class:`~multiprocessing.Process`).  This value will automatically inherited by
 any :class:`~multiprocessing.Process` object that the current process creates.
 This means that (by default) all processes of a multi-process program will share
diff --git a/Lib/test/test_list.py b/Lib/test/test_list.py
index 51843217718..279afecf927 100644
--- a/Lib/test/test_list.py
+++ b/Lib/test/test_list.py
@@ -15,6 +15,23 @@ class ListTest(list_tests.CommonTest):
         self.assertEqual(list(''), [])
         self.assertEqual(list('spam'), ['s', 'p', 'a', 'm'])
 
+        if sys.maxsize == 0x7fffffff:
+            # This test can currently only work on 32-bit machines.
+            # XXX If/when PySequence_Length() returns a ssize_t, it should be
+            # XXX re-enabled.
+            # Verify clearing of bug #556025.
+            # This assumes that the max data size (sys.maxint) == max
+            # address size this also assumes that the address size is at
+            # least 4 bytes with 8 byte addresses, the bug is not well
+            # tested
+            #
+            # Note: This test is expected to SEGV under Cygwin 1.3.12 or
+            # earlier due to a newlib bug.  See the following mailing list
+            # thread for the details:
+
+            #     http://sources.redhat.com/ml/newlib/2002/msg00369.html
+            self.assertRaises(MemoryError, list, range(sys.maxsize // 2))
+
         # This code used to segfault in Py2.4a3
         x = []
         x.extend(-y for y in x)
diff --git a/Lib/test/test_re.py b/Lib/test/test_re.py
index 755cb00ae45..17370bb4564 100644
--- a/Lib/test/test_re.py
+++ b/Lib/test/test_re.py
@@ -352,10 +352,6 @@ class ReTests(unittest.TestCase):
         self.assertEqual(re.search(r"\d\D\w\W\s\S",
                                    "1aa! a", re.UNICODE).group(0), "1aa! a")
 
-    def test_ignore_case(self):
-        self.assertEqual(re.match("abc", "ABC", re.I).group(0), "ABC")
-        self.assertEqual(re.match("abc", "ABC", re.I).group(0), "ABC")
-
     def test_bigcharset(self):
         self.assertEqual(re.match("([\u2222\u2223])",
                                   "\u2222").group(1), "\u2222")
@@ -383,6 +379,8 @@ class ReTests(unittest.TestCase):
         self.assertEqual(re.match(r"(a)(?!\s(abc|a))", "a b").group(1), "a")
 
     def test_ignore_case(self):
+        self.assertEqual(re.match("abc", "ABC", re.I).group(0), "ABC")
+        self.assertEqual(re.match("abc", "ABC", re.I).group(0), "ABC")
         self.assertEqual(re.match(r"(a\s[^a])", "a b", re.I).group(1), "a b")
         self.assertEqual(re.match(r"(a\s[^a]*)", "a bb", re.I).group(1), "a bb")
         self.assertEqual(re.match(r"(a\s[abc])", "a b", re.I).group(1), "a b")
diff --git a/Misc/build.sh b/Misc/build.sh
index efbad56949b..0f76d8534c3 100755
--- a/Misc/build.sh
+++ b/Misc/build.sh
@@ -67,7 +67,7 @@ REFLOG="build/reflog.txt.out"
 # Note: test_XXX (none currently) really leak, but are disabled
 # so we don't send spam.  Any test which really leaks should only 
 # be listed here if there are also test cases under Lib/test/leakers.
-LEAKY_TESTS="test_(asynchat|cmd_line|popen2|socket|smtplib|sys|threadsignals|urllib2_localnet|httpservers)"
+LEAKY_TESTS="test_(asynchat|cmd_line|docxmlrpc|dumbdbm|file|ftplib|httpservers|imaplib|popen2|socket|smtplib|sys|telnetlib|threadedtempfile|threading|threadsignals|urllib2_localnet|xmlrpc)"
 
 # These tests always fail, so skip them so we don't get false positives.
 _ALWAYS_SKIP=""
diff --git a/Modules/_collectionsmodule.c b/Modules/_collectionsmodule.c
index 1763efe3bc9..b26470ea592 100644
--- a/Modules/_collectionsmodule.c
+++ b/Modules/_collectionsmodule.c
@@ -670,8 +670,9 @@ deque_repr(PyObject *deque)
 		return NULL;
 	}
 	if (((dequeobject *)deque)->maxlen != -1)
-		result = PyUnicode_FromFormat("deque(%R, maxlen=%i)", aslist,
-                                              ((dequeobject *)deque)->maxlen);
+
+		result = PyUnicode_FromFormat("deque(%R, maxlen=%" PY_FORMAT_SIZE_T "d)", 
+                                              aslist, ((dequeobject *)deque)->maxlen);
 	else
 		result = PyUnicode_FromFormat("deque(%R)", aslist);
 	Py_DECREF(aslist);
diff --git a/Modules/_testcapimodule.c b/Modules/_testcapimodule.c
index 995d789cfa6..940605e4765 100644
--- a/Modules/_testcapimodule.c
+++ b/Modules/_testcapimodule.c
@@ -714,14 +714,17 @@ raise_exception(PyObject *self, PyObject *args)
  */
 static PyThread_type_lock thread_done = NULL;
 
-static void
+static int
 _make_call(void *callable)
 {
 	PyObject *rc;
+	int success;
 	PyGILState_STATE s = PyGILState_Ensure();
 	rc = PyObject_CallFunction((PyObject *)callable, "");
+	success = (rc != NULL);
 	Py_XDECREF(rc);
 	PyGILState_Release(s);
+	return success;
 }
 
 /* Same thing, but releases `thread_done` when it returns.  This variant
@@ -738,10 +741,17 @@ static PyObject *
 test_thread_state(PyObject *self, PyObject *args)
 {
 	PyObject *fn;
+	int success = 1;
 
 	if (!PyArg_ParseTuple(args, "O:test_thread_state", &fn))
 		return NULL;
 
+	if (!PyCallable_Check(fn)) {
+		PyErr_Format(PyExc_TypeError, "'%s' object is not callable",
+			fn->ob_type->tp_name);
+		return NULL;
+	}
+
 	/* Ensure Python is set up for threading */
 	PyEval_InitThreads();
 	thread_done = PyThread_allocate_lock();
@@ -752,10 +762,10 @@ test_thread_state(PyObject *self, PyObject *args)
 	/* Start a new thread with our callback. */
 	PyThread_start_new_thread(_make_call_from_thread, fn);
 	/* Make the callback with the thread lock held by this thread */
-	_make_call(fn);
+	success &= _make_call(fn);
 	/* Do it all again, but this time with the thread-lock released */
 	Py_BEGIN_ALLOW_THREADS
-	_make_call(fn);
+	success &= _make_call(fn);
 	PyThread_acquire_lock(thread_done, 1);  /* wait for thread to finish */
 	Py_END_ALLOW_THREADS
 
@@ -765,7 +775,7 @@ test_thread_state(PyObject *self, PyObject *args)
 	*/
 	Py_BEGIN_ALLOW_THREADS
 	PyThread_start_new_thread(_make_call_from_thread, fn);
-	_make_call(fn);
+	success &= _make_call(fn);
 	PyThread_acquire_lock(thread_done, 1);  /* wait for thread to finish */
 	Py_END_ALLOW_THREADS
 
@@ -773,6 +783,8 @@ test_thread_state(PyObject *self, PyObject *args)
 	PyThread_release_lock(thread_done);
 
 	PyThread_free_lock(thread_done);
+	if (!success)
+		return NULL;
 	Py_RETURN_NONE;
 }
 #endif
diff --git a/Objects/bytearrayobject.c b/Objects/bytearrayobject.c
index 201d294e8ad..03e51e8a43d 100644
--- a/Objects/bytearrayobject.c
+++ b/Objects/bytearrayobject.c
@@ -1026,6 +1026,7 @@ bytes_dealloc(PyByteArrayObject *self)
 #define STRINGLIB_EMPTY nullbytes
 #define STRINGLIB_CHECK_EXACT PyByteArray_CheckExact
 #define STRINGLIB_MUTABLE 1
+#define FROM_BYTEARRAY 1
 
 #include "stringlib/fastsearch.h"
 #include "stringlib/count.h"
diff --git a/Objects/stringlib/find.h b/Objects/stringlib/find.h
index 46337e1773e..ac37b407a50 100644
--- a/Objects/stringlib/find.h
+++ b/Objects/stringlib/find.h
@@ -90,7 +90,7 @@ stringlib_rfind_slice(const STRINGLIB_CHAR* str, Py_ssize_t str_len,
     return stringlib_rfind(str + start, end - start, sub, sub_len, start);
 }
 
-#ifdef STRINGLIB_WANT_CONTAINS_OBJ
+#ifdef STRINGLIB_WANT_CONTAINS_OBJ && !defined(FROM_BYTEARRAY)
 
 Py_LOCAL_INLINE(int)
 stringlib_contains_obj(PyObject* str, PyObject* sub)