Merge 3.5.2rc1 with current 3.5 branch.

28 files changed, 370 insertions, 424 deletions

diff --git a/Doc/c-api/structures.rst b/Doc/c-api/structures.rst
index e9e8add..cc84314 100644
--- a/Doc/c-api/structures.rst
+++ b/Doc/c-api/structures.rst
@@ -150,9 +150,8 @@ specific C type of the *self* object.
 The :attr:`ml_flags` field is a bitfield which can include the following flags.
 The individual flags indicate either a calling convention or a binding
 convention.  Of the calling convention flags, only :const:`METH_VARARGS` and
-:const:`METH_KEYWORDS` can be combined (but note that :const:`METH_KEYWORDS`
-alone is equivalent to ``METH_VARARGS | METH_KEYWORDS``). Any of the calling
-convention flags can be combined with a binding flag.
+:const:`METH_KEYWORDS` can be combined. Any of the calling convention flags
+can be combined with a binding flag.
 
 
 .. data:: METH_VARARGS
diff --git a/Doc/library/multiprocessing.rst b/Doc/library/multiprocessing.rst
index c5c092c..d20098f 100644
--- a/Doc/library/multiprocessing.rst
+++ b/Doc/library/multiprocessing.rst
@@ -1010,7 +1010,7 @@ Connection objects are usually created using :func:`Pipe` -- see also
       using :meth:`recv`.
 
       The object must be picklable.  Very large pickles (approximately 32 MB+,
-      though it depends on the OS) may raise a ValueError exception.
+      though it depends on the OS) may raise a :exc:`ValueError` exception.
 
    .. method:: recv()
 
@@ -2723,12 +2723,7 @@ start method.
 
 More picklability
 
-    Ensure that all arguments to :meth:`Process.__init__` are
-    picklable.  This means, in particular, that bound or unbound
-    methods cannot be used directly as the ``target`` (unless you use
-    the *fork* start method) --- just define a function and use that
-    instead.
-
+    Ensure that all arguments to :meth:`Process.__init__` are picklable.
     Also, if you subclass :class:`~multiprocessing.Process` then make sure that
     instances will be picklable when the :meth:`Process.start
     <multiprocessing.Process.start>` method is called.
diff --git a/Doc/library/sqlite3.rst b/Doc/library/sqlite3.rst
index 3bba935..ae4c7c4 100644
--- a/Doc/library/sqlite3.rst
+++ b/Doc/library/sqlite3.rst
@@ -309,25 +309,26 @@ Connection Objects
       call :meth:`commit`. If you just close your database connection without
       calling :meth:`commit` first, your changes will be lost!
 
-   .. method:: execute(sql, [parameters])
+   .. method:: execute(sql[, parameters])
 
-      This is a nonstandard shortcut that creates an intermediate cursor object by
-      calling the cursor method, then calls the cursor's :meth:`execute
-      <Cursor.execute>` method with the parameters given.
+      This is a nonstandard shortcut that creates a cursor object by calling
+      the :meth:`~Connection.cursor` method, calls the cursor's
+      :meth:`~Cursor.execute` method with the *parameters* given, and returns
+      the cursor.
 
+   .. method:: executemany(sql[, parameters])
 
-   .. method:: executemany(sql, [parameters])
-
-      This is a nonstandard shortcut that creates an intermediate cursor object by
-      calling the cursor method, then calls the cursor's :meth:`executemany
-      <Cursor.executemany>` method with the parameters given.
+      This is a nonstandard shortcut that creates a cursor object by
+      calling the :meth:`~Connection.cursor` method, calls the cursor's
+      :meth:`~Cursor.executemany` method with the *parameters* given, and
+      returns the cursor.
 
    .. method:: executescript(sql_script)
 
-      This is a nonstandard shortcut that creates an intermediate cursor object by
-      calling the cursor method, then calls the cursor's :meth:`executescript
-      <Cursor.executescript>` method with the parameters given.
-
+      This is a nonstandard shortcut that creates a cursor object by
+      calling the :meth:`~Connection.cursor` method, calls the cursor's
+      :meth:`~Cursor.executescript` method with the given *sql_script*, and
+      returns the cursor.
 
    .. method:: create_function(name, num_params, func)
 
@@ -533,7 +534,7 @@ Cursor Objects
 
    A :class:`Cursor` instance has the following attributes and methods.
 
-   .. method:: execute(sql, [parameters])
+   .. method:: execute(sql[, parameters])
 
       Executes an SQL statement. The SQL statement may be parameterized (i. e.
       placeholders instead of SQL literals). The :mod:`sqlite3` module supports two
@@ -545,7 +546,7 @@ Cursor Objects
       .. literalinclude:: ../includes/sqlite3/execute_1.py
 
       :meth:`execute` will only execute a single SQL statement. If you try to execute
-      more than one statement with it, it will raise a Warning. Use
+      more than one statement with it, it will raise an ``sqlite3.Warning``. Use
       :meth:`executescript` if you want to execute multiple SQL statements with one
       call.
 
@@ -553,8 +554,8 @@ Cursor Objects
    .. method:: executemany(sql, seq_of_parameters)
 
       Executes an SQL command against all parameter sequences or mappings found in
-      the sequence *sql*.  The :mod:`sqlite3` module also allows using an
-      :term:`iterator` yielding parameters instead of a sequence.
+      the sequence *seq_of_parameters*.  The :mod:`sqlite3` module also allows
+      using an :term:`iterator` yielding parameters instead of a sequence.
 
       .. literalinclude:: ../includes/sqlite3/executemany_1.py
 
@@ -569,7 +570,7 @@ Cursor Objects
       at once. It issues a ``COMMIT`` statement first, then executes the SQL script it
       gets as a parameter.
 
-      *sql_script* can be an instance of :class:`str` or :class:`bytes`.
+      *sql_script* can be an instance of :class:`str`.
 
       Example:
 
diff --git a/Doc/whatsnew/2.0.rst b/Doc/whatsnew/2.0.rst
index 87462f3..4d49af1 100644
--- a/Doc/whatsnew/2.0.rst
+++ b/Doc/whatsnew/2.0.rst
@@ -506,7 +506,7 @@ arguments and/or a dictionary of keyword arguments. In Python 1.5 and earlier,
 you'd use the :func:`apply` built-in function: ``apply(f, args, kw)`` calls the
 function :func:`f` with the argument tuple *args* and the keyword arguments in
 the dictionary *kw*.  :func:`apply`  is the same in 2.0, but thanks to a patch
-from Greg Ewing, ``f(*args, **kw)`` as a shorter and clearer way to achieve the
+from Greg Ewing, ``f(*args, **kw)`` is a shorter and clearer way to achieve the
 same effect.  This syntax is symmetrical with the syntax for defining
 functions::
 
diff --git a/Lib/importlib/_bootstrap_external.py b/Lib/importlib/_bootstrap_external.py
index 9788828..08ddb2b 100644
--- a/Lib/importlib/_bootstrap_external.py
+++ b/Lib/importlib/_bootstrap_external.py
@@ -223,6 +223,7 @@ _code_type = type(_write_atomic.__code__)
 #     Python 3.5b1  3330 (PEP 448: Additional Unpacking Generalizations)
 #     Python 3.5b2  3340 (fix dictionary display evaluation order #11205)
 #     Python 3.5b2  3350 (add GET_YIELD_FROM_ITER opcode #24400)
+#     Python 3.5.2  3351 (fix BUILD_MAP_UNPACK_WITH_CALL opcode #27286)
 #
 # MAGIC must change whenever the bytecode emitted by the compiler may no
 # longer be understood by older implementations of the eval loop (usually
@@ -231,7 +232,7 @@ _code_type = type(_write_atomic.__code__)
 # Whenever MAGIC_NUMBER is changed, the ranges in the magic_values array
 # in PC/launcher.c must also be updated.
 
-MAGIC_NUMBER = (3350).to_bytes(2, 'little') + b'\r\n'
+MAGIC_NUMBER = (3351).to_bytes(2, 'little') + b'\r\n'
 _RAW_MAGIC_NUMBER = int.from_bytes(MAGIC_NUMBER, 'little')  # For import.c
 
 _PYCACHE = '__pycache__'
diff --git a/Lib/lib2to3/tests/test_refactor.py b/Lib/lib2to3/tests/test_refactor.py
index f30c1e8..8563001 100644
--- a/Lib/lib2to3/tests/test_refactor.py
+++ b/Lib/lib2to3/tests/test_refactor.py
@@ -9,6 +9,7 @@ import os
 import codecs
 import operator
 import io
+import re
 import tempfile
 import shutil
 import unittest
@@ -226,8 +227,8 @@ from __future__ import print_function"""
                                     actually_write=False)
         # Testing that it logged this message when write=False was passed is
         # sufficient to see that it did not bail early after "No changes".
-        message_regex = r"Not writing changes to .*%s%s" % (
-                os.sep, os.path.basename(test_file))
+        message_regex = r"Not writing changes to .*%s" % \
+                re.escape(os.sep + os.path.basename(test_file))
         for message in debug_messages:
             if "Not writing changes" in message:
                 self.assertRegex(message, message_regex)
diff --git a/Lib/pydoc.py b/Lib/pydoc.py
index 3ca08c9..0d0d0ab 100755
--- a/Lib/pydoc.py
+++ b/Lib/pydoc.py
@@ -28,7 +28,7 @@ to a file named "<name>.html".
 
 Module docs for core modules are assumed to be in
 
-    http://docs.python.org/X.Y/library/
+    https://docs.python.org/X.Y/library/
 
 This can be overridden by setting the PYTHONDOCS environment variable
 to a different URL or to a local directory containing the Library
@@ -395,6 +395,7 @@ class Doc:
 
         docloc = os.environ.get("PYTHONDOCS", self.PYTHONDOCS)
 
+        basedir = os.path.normcase(basedir)
         if (isinstance(object, type(os)) and
             (object.__name__ in ('errno', 'exceptions', 'gc', 'imp',
                                  'marshal', 'posix', 'signal', 'sys',
@@ -402,7 +403,7 @@ class Doc:
              (file.startswith(basedir) and
               not file.startswith(os.path.join(basedir, 'site-packages')))) and
             object.__name__ not in ('xml.etree', 'test.pydoc_mod')):
-            if docloc.startswith("http://"):
+            if docloc.startswith(("http://", "https://")):
                 docloc = "%s/%s" % (docloc.rstrip("/"), object.__name__.lower())
             else:
                 docloc = os.path.join(docloc, object.__name__.lower() + ".html")
diff --git a/Lib/sqlite3/test/dbapi.py b/Lib/sqlite3/test/dbapi.py
index 04649fc..6057805 100644
--- a/Lib/sqlite3/test/dbapi.py
+++ b/Lib/sqlite3/test/dbapi.py
@@ -122,11 +122,8 @@ class ConnectionTests(unittest.TestCase):
 
     def CheckFailedOpen(self):
         YOU_CANNOT_OPEN_THIS = "/foo/bar/bla/23534/mydb.db"
-        try:
+        with self.assertRaises(sqlite.OperationalError):
             con = sqlite.connect(YOU_CANNOT_OPEN_THIS)
-        except sqlite.OperationalError:
-            return
-        self.fail("should have raised an OperationalError")
 
     def CheckClose(self):
         self.cx.close()
@@ -180,6 +177,12 @@ class ConnectionTests(unittest.TestCase):
             with self.assertRaises(sqlite.OperationalError):
                 cx.execute('insert into test(id) values(1)')
 
+    def CheckSameThreadErrorOnOldVersion(self):
+        if sqlite.sqlite_version_info >= (3, 3, 1):
+            self.skipTest('test needs sqlite3 versions older than 3.3.1')
+        with self.assertRaises(sqlite.NotSupportedError) as cm:
+            sqlite.connect(':memory:', check_same_thread=False)
+        self.assertEqual(str(cm.exception), 'shared connections not available')
 
 class CursorTests(unittest.TestCase):
     def setUp(self):
@@ -196,22 +199,12 @@ class CursorTests(unittest.TestCase):
         self.cu.execute("delete from test")
 
     def CheckExecuteIllegalSql(self):
-        try:
+        with self.assertRaises(sqlite.OperationalError):
             self.cu.execute("select asdf")
-            self.fail("should have raised an OperationalError")
-        except sqlite.OperationalError:
-            return
-        except:
-            self.fail("raised wrong exception")
 
     def CheckExecuteTooMuchSql(self):
-        try:
+        with self.assertRaises(sqlite.Warning):
             self.cu.execute("select 5+4; select 4+5")
-            self.fail("should have raised a Warning")
-        except sqlite.Warning:
-            return
-        except:
-            self.fail("raised wrong exception")
 
     def CheckExecuteTooMuchSql2(self):
         self.cu.execute("select 5+4; -- foo bar")
@@ -226,13 +219,8 @@ class CursorTests(unittest.TestCase):
             """)
 
     def CheckExecuteWrongSqlArg(self):
-        try:
+        with self.assertRaises(ValueError):
             self.cu.execute(42)
-            self.fail("should have raised a ValueError")
-        except ValueError:
-            return
-        except:
-            self.fail("raised wrong exception.")
 
     def CheckExecuteArgInt(self):
         self.cu.execute("insert into test(id) values (?)", (42,))
@@ -250,29 +238,25 @@ class CursorTests(unittest.TestCase):
         row = self.cu.fetchone()
         self.assertEqual(row[0], "Hu\x00go")
 
+    def CheckExecuteNonIterable(self):
+        with self.assertRaises(ValueError) as cm:
+            self.cu.execute("insert into test(id) values (?)", 42)
+        self.assertEqual(str(cm.exception), 'parameters are of unsupported type')
+
     def CheckExecuteWrongNoOfArgs1(self):
         # too many parameters
-        try:
+        with self.assertRaises(sqlite.ProgrammingError):
             self.cu.execute("insert into test(id) values (?)", (17, "Egon"))
-            self.fail("should have raised ProgrammingError")
-        except sqlite.ProgrammingError:
-            pass
 
     def CheckExecuteWrongNoOfArgs2(self):
         # too little parameters
-        try:
+        with self.assertRaises(sqlite.ProgrammingError):
             self.cu.execute("insert into test(id) values (?)")
-            self.fail("should have raised ProgrammingError")
-        except sqlite.ProgrammingError:
-            pass
 
     def CheckExecuteWrongNoOfArgs3(self):
         # no parameters, parameters are needed
-        try:
+        with self.assertRaises(sqlite.ProgrammingError):
             self.cu.execute("insert into test(id) values (?)")
-            self.fail("should have raised ProgrammingError")
-        except sqlite.ProgrammingError:
-            pass
 
     def CheckExecuteParamList(self):
         self.cu.execute("insert into test(name) values ('foo')")
@@ -311,27 +295,18 @@ class CursorTests(unittest.TestCase):
 
     def CheckExecuteDictMappingTooLittleArgs(self):
         self.cu.execute("insert into test(name) values ('foo')")
-        try:
+        with self.assertRaises(sqlite.ProgrammingError):
             self.cu.execute("select name from test where name=:name and id=:id", {"name": "foo"})
-            self.fail("should have raised ProgrammingError")
-        except sqlite.ProgrammingError:
-            pass
 
     def CheckExecuteDictMappingNoArgs(self):
         self.cu.execute("insert into test(name) values ('foo')")
-        try:
+        with self.assertRaises(sqlite.ProgrammingError):
             self.cu.execute("select name from test where name=:name")
-            self.fail("should have raised ProgrammingError")
-        except sqlite.ProgrammingError:
-            pass
 
     def CheckExecuteDictMappingUnnamed(self):
         self.cu.execute("insert into test(name) values ('foo')")
-        try:
+        with self.assertRaises(sqlite.ProgrammingError):
             self.cu.execute("select name from test where name=?", {"name": "foo"})
-            self.fail("should have raised ProgrammingError")
-        except sqlite.ProgrammingError:
-            pass
 
     def CheckClose(self):
         self.cu.close()
@@ -392,32 +367,16 @@ class CursorTests(unittest.TestCase):
         self.cu.executemany("insert into test(income) values (?)", mygen())
 
     def CheckExecuteManyWrongSqlArg(self):
-        try:
+        with self.assertRaises(ValueError):
             self.cu.executemany(42, [(3,)])
-            self.fail("should have raised a ValueError")
-        except ValueError:
-            return
-        except:
-            self.fail("raised wrong exception.")
 
     def CheckExecuteManySelect(self):
-        try:
+        with self.assertRaises(sqlite.ProgrammingError):
             self.cu.executemany("select ?", [(3,)])
-            self.fail("should have raised a ProgrammingError")
-        except sqlite.ProgrammingError:
-            return
-        except:
-            self.fail("raised wrong exception.")
 
     def CheckExecuteManyNotIterable(self):
-        try:
+        with self.assertRaises(TypeError):
             self.cu.executemany("insert into test(income) values (?)", 42)
-            self.fail("should have raised a TypeError")
-        except TypeError:
-            return
-        except Exception as e:
-            print("raised", e.__class__)
-            self.fail("raised wrong exception.")
 
     def CheckFetchIter(self):
         # Optional DB-API extension.
@@ -494,22 +453,15 @@ class CursorTests(unittest.TestCase):
         self.assertEqual(self.cu.connection, self.cx)
 
     def CheckWrongCursorCallable(self):
-        try:
+        with self.assertRaises(TypeError):
             def f(): pass
             cur = self.cx.cursor(f)
-            self.fail("should have raised a TypeError")
-        except TypeError:
-            return
-        self.fail("should have raised a ValueError")
 
     def CheckCursorWrongClass(self):
         class Foo: pass
         foo = Foo()
-        try:
+        with self.assertRaises(TypeError):
             cur = sqlite.Cursor(foo)
-            self.fail("should have raised a ValueError")
-        except TypeError:
-            pass
 
 @unittest.skipUnless(threading, 'This test requires threading.')
 class ThreadTests(unittest.TestCase):
@@ -708,22 +660,21 @@ class ExtensionTests(unittest.TestCase):
     def CheckScriptSyntaxError(self):
         con = sqlite.connect(":memory:")
         cur = con.cursor()
-        raised = False
-        try:
+        with self.assertRaises(sqlite.OperationalError):
             cur.executescript("create table test(x); asdf; create table test2(x)")
-        except sqlite.OperationalError:
-            raised = True
-        self.assertEqual(raised, True, "should have raised an exception")
 
     def CheckScriptErrorNormal(self):
         con = sqlite.connect(":memory:")
         cur = con.cursor()
-        raised = False
-        try:
+        with self.assertRaises(sqlite.OperationalError):
             cur.executescript("create table test(sadfsadfdsa); select foo from hurz;")
-        except sqlite.OperationalError:
-            raised = True
-        self.assertEqual(raised, True, "should have raised an exception")
+
+    def CheckCursorExecutescriptAsBytes(self):
+        con = sqlite.connect(":memory:")
+        cur = con.cursor()
+        with self.assertRaises(ValueError) as cm:
+            cur.executescript(b"create table test(foo); insert into test(foo) values (5);")
+        self.assertEqual(str(cm.exception), 'script argument must be unicode.')
 
     def CheckConnectionExecute(self):
         con = sqlite.connect(":memory:")
@@ -754,59 +705,34 @@ class ClosedConTests(unittest.TestCase):
     def CheckClosedConCursor(self):
         con = sqlite.connect(":memory:")
         con.close()
-        try:
+        with self.assertRaises(sqlite.ProgrammingError):
             cur = con.cursor()
-            self.fail("Should have raised a ProgrammingError")
-        except sqlite.ProgrammingError:
-            pass
-        except:
-            self.fail("Should have raised a ProgrammingError")
 
     def CheckClosedConCommit(self):
         con = sqlite.connect(":memory:")
         con.close()
-        try:
+        with self.assertRaises(sqlite.ProgrammingError):
             con.commit()
-            self.fail("Should have raised a ProgrammingError")
-        except sqlite.ProgrammingError:
-            pass
-        except:
-            self.fail("Should have raised a ProgrammingError")
 
     def CheckClosedConRollback(self):
         con = sqlite.connect(":memory:")
         con.close()
-        try:
+        with self.assertRaises(sqlite.ProgrammingError):
             con.rollback()
-            self.fail("Should have raised a ProgrammingError")
-        except sqlite.ProgrammingError:
-            pass
-        except:
-            self.fail("Should have raised a ProgrammingError")
 
     def CheckClosedCurExecute(self):
         con = sqlite.connect(":memory:")
         cur = con.cursor()
         con.close()
-        try:
+        with self.assertRaises(sqlite.ProgrammingError):
             cur.execute("select 4")
-            self.fail("Should have raised a ProgrammingError")
-        except sqlite.ProgrammingError:
-            pass
-        except:
-            self.fail("Should have raised a ProgrammingError")
 
     def CheckClosedCreateFunction(self):
         con = sqlite.connect(":memory:")
         con.close()
         def f(x): return 17
-        try:
+        with self.assertRaises(sqlite.ProgrammingError):
             con.create_function("foo", 1, f)
-            self.fail("Should have raised a ProgrammingError")
-        except sqlite.ProgrammingError:
-            pass
-        except:
-            self.fail("Should have raised a ProgrammingError")
 
     def CheckClosedCreateAggregate(self):
         con = sqlite.connect(":memory:")
@@ -818,49 +744,29 @@ class ClosedConTests(unittest.TestCase):
                 pass
             def finalize(self):
                 return 17
-        try:
+        with self.assertRaises(sqlite.ProgrammingError):
             con.create_aggregate("foo", 1, Agg)
-            self.fail("Should have raised a ProgrammingError")
-        except sqlite.ProgrammingError:
-            pass
-        except:
-            self.fail("Should have raised a ProgrammingError")
 
     def CheckClosedSetAuthorizer(self):
         con = sqlite.connect(":memory:")
         con.close()
         def authorizer(*args):
             return sqlite.DENY
-        try:
+        with self.assertRaises(sqlite.ProgrammingError):
             con.set_authorizer(authorizer)
-            self.fail("Should have raised a ProgrammingError")
-        except sqlite.ProgrammingError:
-            pass
-        except:
-            self.fail("Should have raised a ProgrammingError")
 
     def CheckClosedSetProgressCallback(self):
         con = sqlite.connect(":memory:")
         con.close()
         def progress(): pass
-        try:
+        with self.assertRaises(sqlite.ProgrammingError):
             con.set_progress_handler(progress, 100)
-            self.fail("Should have raised a ProgrammingError")
-        except sqlite.ProgrammingError:
-            pass
-        except:
-            self.fail("Should have raised a ProgrammingError")
 
     def CheckClosedCall(self):
         con = sqlite.connect(":memory:")
         con.close()
-        try:
+        with self.assertRaises(sqlite.ProgrammingError):
             con()
-            self.fail("Should have raised a ProgrammingError")
-        except sqlite.ProgrammingError:
-            pass
-        except:
-            self.fail("Should have raised a ProgrammingError")
 
 class ClosedCurTests(unittest.TestCase):
     def setUp(self):
@@ -882,15 +788,9 @@ class ClosedCurTests(unittest.TestCase):
             else:
                 params = []
 
-            try:
+            with self.assertRaises(sqlite.ProgrammingError):
                 method = getattr(cur, method_name)
-
                 method(*params)
-                self.fail("Should have raised a ProgrammingError: method " + method_name)
-            except sqlite.ProgrammingError:
-                pass
-            except:
-                self.fail("Should have raised a ProgrammingError: " + method_name)
 
 def suite():
     module_suite = unittest.makeSuite(ModuleTests, "Check")
diff --git a/Lib/sqlite3/test/hooks.py b/Lib/sqlite3/test/hooks.py
index ede0bec..67653ae 100644
--- a/Lib/sqlite3/test/hooks.py
+++ b/Lib/sqlite3/test/hooks.py
@@ -33,19 +33,14 @@ class CollationTests(unittest.TestCase):
 
     def CheckCreateCollationNotCallable(self):
         con = sqlite.connect(":memory:")
-        try:
+        with self.assertRaises(TypeError) as cm:
             con.create_collation("X", 42)
-            self.fail("should have raised a TypeError")
-        except TypeError as e:
-            self.assertEqual(e.args[0], "parameter must be callable")
+        self.assertEqual(str(cm.exception), 'parameter must be callable')
 
     def CheckCreateCollationNotAscii(self):
         con = sqlite.connect(":memory:")
-        try:
+        with self.assertRaises(sqlite.ProgrammingError):
             con.create_collation("collä", lambda x, y: (x > y) - (x < y))
-            self.fail("should have raised a ProgrammingError")
-        except sqlite.ProgrammingError as e:
-            pass
 
     @unittest.skipIf(sqlite.sqlite_version_info < (3, 2, 1),
                      'old SQLite versions crash on this test')
@@ -70,11 +65,9 @@ class CollationTests(unittest.TestCase):
             self.fail("the expected order was not returned")
 
         con.create_collation("mycoll", None)
-        try:
+        with self.assertRaises(sqlite.OperationalError) as cm:
             result = con.execute(sql).fetchall()
-            self.fail("should have raised an OperationalError")
-        except sqlite.OperationalError as e:
-            self.assertEqual(e.args[0].lower(), "no such collation sequence: mycoll")
+        self.assertEqual(str(cm.exception), 'no such collation sequence: mycoll')
 
     def CheckCollationReturnsLargeInteger(self):
         def mycoll(x, y):
@@ -106,8 +99,8 @@ class CollationTests(unittest.TestCase):
         result = con.execute("""
             select x from (select 'a' as x union select 'b' as x) order by x collate mycoll
             """).fetchall()
-        if result[0][0] != 'b' or result[1][0] != 'a':
-            self.fail("wrong collation function is used")
+        self.assertEqual(result[0][0], 'b')
+        self.assertEqual(result[1][0], 'a')
 
     def CheckDeregisterCollation(self):
         """
@@ -117,12 +110,9 @@ class CollationTests(unittest.TestCase):
         con = sqlite.connect(":memory:")
         con.create_collation("mycoll", lambda x, y: (x > y) - (x < y))
         con.create_collation("mycoll", None)
-        try:
+        with self.assertRaises(sqlite.OperationalError) as cm:
             con.execute("select 'a' as x union select 'b' as x order by x collate mycoll")
-            self.fail("should have raised an OperationalError")
-        except sqlite.OperationalError as e:
-            if not e.args[0].startswith("no such collation sequence"):
-                self.fail("wrong OperationalError raised")
+        self.assertEqual(str(cm.exception), 'no such collation sequence: mycoll')
 
 class ProgressTests(unittest.TestCase):
     def CheckProgressHandlerUsed(self):
diff --git a/Lib/sqlite3/test/regression.py b/Lib/sqlite3/test/regression.py
index 11adb30..85ace84 100644
--- a/Lib/sqlite3/test/regression.py
+++ b/Lib/sqlite3/test/regression.py
@@ -170,14 +170,8 @@ class RegressionTests(unittest.TestCase):
 
         con = sqlite.connect(":memory:")
         cur = Cursor(con)
-        try:
+        with self.assertRaises(sqlite.ProgrammingError):
             cur.execute("select 4+5").fetchall()
-            self.fail("should have raised ProgrammingError")
-        except sqlite.ProgrammingError:
-            pass
-        except:
-            self.fail("should have raised ProgrammingError")
-
 
     def CheckStrSubclass(self):
         """
@@ -196,13 +190,8 @@ class RegressionTests(unittest.TestCase):
                 pass
 
         con = Connection(":memory:")
-        try:
+        with self.assertRaises(sqlite.ProgrammingError):
             cur = con.cursor()
-            self.fail("should have raised ProgrammingError")
-        except sqlite.ProgrammingError:
-            pass
-        except:
-            self.fail("should have raised ProgrammingError")
 
     def CheckCursorRegistration(self):
         """
@@ -223,13 +212,8 @@ class RegressionTests(unittest.TestCase):
         cur.executemany("insert into foo(x) values (?)", [(3,), (4,), (5,)])
         cur.execute("select x from foo")
         con.rollback()
-        try:
+        with self.assertRaises(sqlite.InterfaceError):
             cur.fetchall()
-            self.fail("should have raised InterfaceError")
-        except sqlite.InterfaceError:
-            pass
-        except:
-            self.fail("should have raised InterfaceError")
 
     def CheckAutoCommit(self):
         """
diff --git a/Lib/sqlite3/test/transactions.py b/Lib/sqlite3/test/transactions.py
index feb4fa1..eae26c4 100644
--- a/Lib/sqlite3/test/transactions.py
+++ b/Lib/sqlite3/test/transactions.py
@@ -118,13 +118,8 @@ class TransactionTests(unittest.TestCase):
             return
         self.cur1.execute("create table test(i)")
         self.cur1.execute("insert into test(i) values (5)")
-        try:
+        with self.assertRaises(sqlite.OperationalError):
             self.cur2.execute("insert into test(i) values (5)")
-            self.fail("should have raised an OperationalError")
-        except sqlite.OperationalError:
-            pass
-        except:
-            self.fail("should have raised an OperationalError")
 
     def CheckLocking(self):
         """
@@ -137,13 +132,8 @@ class TransactionTests(unittest.TestCase):
             return
         self.cur1.execute("create table test(i)")
         self.cur1.execute("insert into test(i) values (5)")
-        try:
+        with self.assertRaises(sqlite.OperationalError):
             self.cur2.execute("insert into test(i) values (5)")
-            self.fail("should have raised an OperationalError")
-        except sqlite.OperationalError:
-            pass
-        except:
-            self.fail("should have raised an OperationalError")
         # NO self.con2.rollback() HERE!!!
         self.con1.commit()
 
@@ -159,13 +149,8 @@ class TransactionTests(unittest.TestCase):
         cur.execute("select 1 union select 2 union select 3")
 
         con.rollback()
-        try:
+        with self.assertRaises(sqlite.InterfaceError):
             cur.fetchall()
-            self.fail("InterfaceError should have been raised")
-        except sqlite.InterfaceError as e:
-            pass
-        except:
-            self.fail("InterfaceError should have been raised")
 
 class SpecialCommandTests(unittest.TestCase):
     def setUp(self):
diff --git a/Lib/sqlite3/test/types.py b/Lib/sqlite3/test/types.py
index adad571..f7c8f9c 100644
--- a/Lib/sqlite3/test/types.py
+++ b/Lib/sqlite3/test/types.py
@@ -185,24 +185,14 @@ class DeclTypesTests(unittest.TestCase):
     def CheckUnsupportedSeq(self):
         class Bar: pass
         val = Bar()
-        try:
+        with self.assertRaises(sqlite.InterfaceError):
             self.cur.execute("insert into test(f) values (?)", (val,))
-            self.fail("should have raised an InterfaceError")
-        except sqlite.InterfaceError:
-            pass
-        except:
-            self.fail("should have raised an InterfaceError")
 
     def CheckUnsupportedDict(self):
         class Bar: pass
         val = Bar()
-        try:
+        with self.assertRaises(sqlite.InterfaceError):
             self.cur.execute("insert into test(f) values (:val)", {"val": val})
-            self.fail("should have raised an InterfaceError")
-        except sqlite.InterfaceError:
-            pass
-        except:
-            self.fail("should have raised an InterfaceError")
 
     def CheckBlob(self):
         # default
diff --git a/Lib/sqlite3/test/userfunctions.py b/Lib/sqlite3/test/userfunctions.py
index 8a4bbab..4075045 100644
--- a/Lib/sqlite3/test/userfunctions.py
+++ b/Lib/sqlite3/test/userfunctions.py
@@ -162,11 +162,8 @@ class FunctionTests(unittest.TestCase):
         self.con.close()
 
     def CheckFuncErrorOnCreate(self):
-        try:
+        with self.assertRaises(sqlite.OperationalError):
             self.con.create_function("bla", -100, lambda x: 2*x)
-            self.fail("should have raised an OperationalError")
-        except sqlite.OperationalError:
-            pass
 
     def CheckFuncRefCount(self):
         def getfunc():
@@ -231,12 +228,10 @@ class FunctionTests(unittest.TestCase):
 
     def CheckFuncException(self):
         cur = self.con.cursor()
-        try:
+        with self.assertRaises(sqlite.OperationalError) as cm:
             cur.execute("select raiseexception()")
             cur.fetchone()
-            self.fail("should have raised OperationalError")
-        except sqlite.OperationalError as e:
-            self.assertEqual(e.args[0], 'user-defined function raised exception')
+        self.assertEqual(str(cm.exception), 'user-defined function raised exception')
 
     def CheckParamString(self):
         cur = self.con.cursor()
@@ -312,55 +307,42 @@ class AggregateTests(unittest.TestCase):
         pass
 
     def CheckAggrErrorOnCreate(self):
-        try:
+        with self.assertRaises(sqlite.OperationalError):
             self.con.create_function("bla", -100, AggrSum)
-            self.fail("should have raised an OperationalError")
-        except sqlite.OperationalError:
-            pass
 
     def CheckAggrNoStep(self):
         cur = self.con.cursor()
-        try:
+        with self.assertRaises(AttributeError) as cm:
             cur.execute("select nostep(t) from test")
-            self.fail("should have raised an AttributeError")
-        except AttributeError as e:
-            self.assertEqual(e.args[0], "'AggrNoStep' object has no attribute 'step'")
+        self.assertEqual(str(cm.exception), "'AggrNoStep' object has no attribute 'step'")
 
     def CheckAggrNoFinalize(self):
         cur = self.con.cursor()
-        try:
+        with self.assertRaises(sqlite.OperationalError) as cm:
             cur.execute("select nofinalize(t) from test")
             val = cur.fetchone()[0]
-            self.fail("should have raised an OperationalError")
-        except sqlite.OperationalError as e:
-            self.assertEqual(e.args[0], "user-defined aggregate's 'finalize' method raised error")
+        self.assertEqual(str(cm.exception), "user-defined aggregate's 'finalize' method raised error")
 
     def CheckAggrExceptionInInit(self):
         cur = self.con.cursor()
-        try:
+        with self.assertRaises(sqlite.OperationalError) as cm:
             cur.execute("select excInit(t) from test")
             val = cur.fetchone()[0]
-            self.fail("should have raised an OperationalError")
-        except sqlite.OperationalError as e:
-            self.assertEqual(e.args[0], "user-defined aggregate's '__init__' method raised error")
+        self.assertEqual(str(cm.exception), "user-defined aggregate's '__init__' method raised error")
 
     def CheckAggrExceptionInStep(self):
         cur = self.con.cursor()
-        try:
+        with self.assertRaises(sqlite.OperationalError) as cm:
             cur.execute("select excStep(t) from test")
             val = cur.fetchone()[0]
-            self.fail("should have raised an OperationalError")
-        except sqlite.OperationalError as e:
-            self.assertEqual(e.args[0], "user-defined aggregate's 'step' method raised error")
+        self.assertEqual(str(cm.exception), "user-defined aggregate's 'step' method raised error")
 
     def CheckAggrExceptionInFinalize(self):
         cur = self.con.cursor()
-        try:
+        with self.assertRaises(sqlite.OperationalError) as cm:
             cur.execute("select excFinalize(t) from test")
             val = cur.fetchone()[0]
-            self.fail("should have raised an OperationalError")
-        except sqlite.OperationalError as e:
-            self.assertEqual(e.args[0], "user-defined aggregate's 'finalize' method raised error")
+        self.assertEqual(str(cm.exception), "user-defined aggregate's 'finalize' method raised error")
 
     def CheckAggrCheckParamStr(self):
         cur = self.con.cursor()
@@ -433,22 +415,14 @@ class AuthorizerTests(unittest.TestCase):
         pass
 
     def test_table_access(self):
-        try:
+        with self.assertRaises(sqlite.DatabaseError) as cm:
             self.con.execute("select * from t2")
-        except sqlite.DatabaseError as e:
-            if not e.args[0].endswith("prohibited"):
-                self.fail("wrong exception text: %s" % e.args[0])
-            return
-        self.fail("should have raised an exception due to missing privileges")
+        self.assertIn('prohibited', str(cm.exception))
 
     def test_column_access(self):
-        try:
+        with self.assertRaises(sqlite.DatabaseError) as cm:
             self.con.execute("select c2 from t1")
-        except sqlite.DatabaseError as e:
-            if not e.args[0].endswith("prohibited"):
-                self.fail("wrong exception text: %s" % e.args[0])
-            return
-        self.fail("should have raised an exception due to missing privileges")
+        self.assertIn('prohibited', str(cm.exception))
 
 class AuthorizerRaiseExceptionTests(AuthorizerTests):
     @staticmethod
diff --git a/Lib/test/support/__init__.py b/Lib/test/support/__init__.py
index e124fab..c9e36fb 100644
--- a/Lib/test/support/__init__.py
+++ b/Lib/test/support/__init__.py
@@ -1349,7 +1349,8 @@ def transient_internet(resource_name, *, timeout=30.0, errnos=()):
              500 <= err.code <= 599) or
             (isinstance(err, urllib.error.URLError) and
                  (("ConnectionRefusedError" in err.reason) or
-                  ("TimeoutError" in err.reason))) or
+                  ("TimeoutError" in err.reason) or
+                  ("EOFError" in err.reason))) or
             n in captured_errnos):
             if not verbose:
                 sys.stderr.write(denied.args[0] + "\n")
diff --git a/Lib/test/test_coroutines.py b/Lib/test/test_coroutines.py
index 4f725ae..d0cefb0 100644
--- a/Lib/test/test_coroutines.py
+++ b/Lib/test/test_coroutines.py
@@ -1423,7 +1423,7 @@ class CoroutineTest(unittest.TestCase):
 
         with warnings.catch_warnings():
             warnings.simplefilter("error")
-            # Test that __aiter__ that returns an asyncronous iterator
+            # Test that __aiter__ that returns an asynchronous iterator
             # directly does not throw any warnings.
             run_async(main())
         self.assertEqual(I, 111011)
diff --git a/Lib/test/test_extcall.py b/Lib/test/test_extcall.py
index d526b5f..5eea379 100644
--- a/Lib/test/test_extcall.py
+++ b/Lib/test/test_extcall.py
@@ -57,6 +57,10 @@ Here we add keyword arguments
     Traceback (most recent call last):
         ...
     TypeError: f() got multiple values for keyword argument 'a'
+    >>> f(1, 2, a=3, **{'a': 4}, **{'a': 5})
+    Traceback (most recent call last):
+        ...
+    TypeError: f() got multiple values for keyword argument 'a'
     >>> f(1, 2, 3, *[4, 5], **{'a':6, 'b':7})
     (1, 2, 3, 4, 5) {'a': 6, 'b': 7}
     >>> f(1, 2, 3, x=4, y=5, *(6, 7), **{'a':8, 'b': 9})
diff --git a/Lib/test/test_functools.py b/Lib/test/test_functools.py
index 9abe984..ab51a35 100644
--- a/Lib/test/test_functools.py
+++ b/Lib/test/test_functools.py
@@ -217,6 +217,33 @@ class TestPartialC(TestPartial, unittest.TestCase):
                       ['{}({!r}, {}, {})'.format(name, capture, args_repr, kwargs_repr)
                        for kwargs_repr in kwargs_reprs])
 
+    def test_recursive_repr(self):
+        if self.partial is c_functools.partial:
+            name = 'functools.partial'
+        else:
+            name = self.partial.__name__
+
+        f = self.partial(capture)
+        f.__setstate__((f, (), {}, {}))
+        try:
+            self.assertEqual(repr(f), '%s(%s(...))' % (name, name))
+        finally:
+            f.__setstate__((capture, (), {}, {}))
+
+        f = self.partial(capture)
+        f.__setstate__((capture, (f,), {}, {}))
+        try:
+            self.assertEqual(repr(f), '%s(%r, %s(...))' % (name, capture, name))
+        finally:
+            f.__setstate__((capture, (), {}, {}))
+
+        f = self.partial(capture)
+        f.__setstate__((capture, (), {'a': f}, {}))
+        try:
+            self.assertEqual(repr(f), '%s(%r, a=%s(...))' % (name, capture, name))
+        finally:
+            f.__setstate__((capture, (), {}, {}))
+
     def test_pickle(self):
         f = self.partial(signature, ['asdf'], bar=[True])
         f.attr = []
@@ -297,6 +324,40 @@ class TestPartialC(TestPartial, unittest.TestCase):
         self.assertEqual(r, ((1, 2), {}))
         self.assertIs(type(r[0]), tuple)
 
+    def test_recursive_pickle(self):
+        f = self.partial(capture)
+        f.__setstate__((f, (), {}, {}))
+        try:
+            for proto in range(pickle.HIGHEST_PROTOCOL + 1):
+                with self.assertRaises(RecursionError):
+                    pickle.dumps(f, proto)
+        finally:
+            f.__setstate__((capture, (), {}, {}))
+
+        f = self.partial(capture)
+        f.__setstate__((capture, (f,), {}, {}))
+        try:
+            for proto in range(pickle.HIGHEST_PROTOCOL + 1):
+                f_copy = pickle.loads(pickle.dumps(f, proto))
+                try:
+                    self.assertIs(f_copy.args[0], f_copy)
+                finally:
+                    f_copy.__setstate__((capture, (), {}, {}))
+        finally:
+            f.__setstate__((capture, (), {}, {}))
+
+        f = self.partial(capture)
+        f.__setstate__((capture, (), {'a': f}, {}))
+        try:
+            for proto in range(pickle.HIGHEST_PROTOCOL + 1):
+                f_copy = pickle.loads(pickle.dumps(f, proto))
+                try:
+                    self.assertIs(f_copy.keywords['a'], f_copy)
+                finally:
+                    f_copy.__setstate__((capture, (), {}, {}))
+        finally:
+            f.__setstate__((capture, (), {}, {}))
+
     # Issue 6083: Reference counting bug
     def test_setstate_refcount(self):
         class BadSequence:
diff --git a/Lib/test/test_pydoc.py b/Lib/test/test_pydoc.py
index 59aa715..aee979b 100644
--- a/Lib/test/test_pydoc.py
+++ b/Lib/test/test_pydoc.py
@@ -356,7 +356,7 @@ def get_pydoc_html(module):
 def get_pydoc_link(module):
     "Returns a documentation web link of a module"
     dirname = os.path.dirname
-    basedir = os.path.join(dirname(dirname(__file__)))
+    basedir = dirname(dirname(__file__))
     doc = pydoc.TextDoc()
     loc = doc.getdocloc(module, basedir=basedir)
     return loc
diff --git a/Lib/test/test_unpack_ex.py b/Lib/test/test_unpack_ex.py
index d27eef0..74346b4 100644
--- a/Lib/test/test_unpack_ex.py
+++ b/Lib/test/test_unpack_ex.py
@@ -248,6 +248,11 @@ Overridden parameters
       ...
     TypeError: f() got multiple values for keyword argument 'x'
 
+    >>> f(x=5, **{'x': 3}, **{'x': 2})
+    Traceback (most recent call last):
+      ...
+    TypeError: f() got multiple values for keyword argument 'x'
+
     >>> f(**{1: 3}, **{1: 5})
     Traceback (most recent call last):
       ...
diff --git a/Lib/test/test_xml_etree.py b/Lib/test/test_xml_etree.py
index 44e3142..bc1dd14 100644
--- a/Lib/test/test_xml_etree.py
+++ b/Lib/test/test_xml_etree.py
@@ -18,7 +18,7 @@ import weakref
 
 from itertools import product
 from test import support
-from test.support import TESTFN, findfile, import_fresh_module, gc_collect
+from test.support import TESTFN, findfile, import_fresh_module, gc_collect, swap_attr
 
 # pyET is the pure-Python implementation.
 #
@@ -1860,6 +1860,12 @@ class BadElementTest(ElementTestCase, unittest.TestCase):
         e.extend([ET.Element('bar')])
         self.assertRaises(ValueError, e.remove, X('baz'))
 
+    def test_recursive_repr(self):
+        # Issue #25455
+        e = ET.Element('foo')
+        with swap_attr(e, 'tag', e):
+            with self.assertRaises(RuntimeError):
+                repr(e)  # Should not crash
 
 class MutatingElementPath(str):
     def __new__(cls, elem, *args):
diff --git a/Misc/NEWS b/Misc/NEWS
index 8979afd..1e06ea8 100644
--- a/Misc/NEWS
+++ b/Misc/NEWS
@@ -2,6 +2,18 @@
 Python News
 +++++++++++
 
+What's New in Python 3.5.3 release candidate 1?
+===============================================
+
+Release date: TBA
+
+Core and Builtins
+-----------------
+
+Library
+-------
+
+
 What's New in Python 3.5.2 final?
 =================================
 
@@ -22,6 +34,13 @@ Release date: 2016-06-12
 Core and Builtins
 -----------------
 
+- Issue #27190: Raise NotSupportedError if sqlite3 is older than 3.3.1.
+  Patch by Dave Sawyer.
+
+- Issue #27286: Fixed compiling BUILD_MAP_UNPACK_WITH_CALL opcode.  Calling
+  function with generalized unpacking (PEP 448) and conflicting keyword names
+  could cause undefined behavior.
+
 - Issue #27066: Fixed SystemError if a custom opener (for open()) returns a
   negative number without setting an exception.
 
@@ -151,6 +170,9 @@ Core and Builtins
 Library
 -------
 
+- Issue #25455: Fixed crashes in repr of recursive ElementTree.Element and
+  functools.partial objects.
+
 - Issue #26556: Update expat to 2.1.1, fixes CVE-2015-1283.
 
 - Fix TLS stripping vulnerability in smptlib, CVE-2016-0772.  Reported by Team
@@ -603,6 +625,10 @@ IDLE
 Documentation
 -------------
 
+- Issue #16484: Change the default PYTHONDOCS URL to "https:", and fix the
+  resulting links to use lowercase.  Patch by Sean Rodman, test by Kaushik
+  Nadikuditi.
+
 - Issue #24136: Document the new PEP 448 unpacking syntax of 3.5.
 
 - Issue #26736: Used HTTPS for external links in the documentation if possible.
@@ -2223,8 +2249,8 @@ Library
   writer failed in BufferedRWPair.close().
 
 - Issue #23622: Unknown escapes in regular expressions that consist of ``'\'``
-  and ASCII letter now raise a deprecation warning and will be forbidden in
-  Python 3.6.
+  and an ASCII letter now raise a deprecation warning and will be forbidden
+  in Python 3.6.
 
 - Issue #23671: string.Template now allows specifying the "self" parameter as
   a keyword argument.  string.Formatter now allows specifying the "self" and
diff --git a/Modules/_elementtree.c b/Modules/_elementtree.c
index 0f1d6a1..85ffca2 100644
--- a/Modules/_elementtree.c
+++ b/Modules/_elementtree.c
@@ -1582,10 +1582,23 @@ _elementtree_Element_remove_impl(ElementObject *self, PyObject *subelement)
 static PyObject*
 element_repr(ElementObject* self)
 {
-    if (self->tag)
-        return PyUnicode_FromFormat("<Element %R at %p>", self->tag, self);
-    else
+    int status;
+
+    if (self->tag == NULL)
         return PyUnicode_FromFormat("<Element at %p>", self);
+
+    status = Py_ReprEnter((PyObject *)self);
+    if (status == 0) {
+        PyObject *res;
+        res = PyUnicode_FromFormat("<Element %R at %p>", self->tag, self);
+        Py_ReprLeave((PyObject *)self);
+        return res;
+    }
+    if (status > 0)
+        PyErr_Format(PyExc_RuntimeError,
+                     "reentrant call inside %s.__repr__",
+                     Py_TYPE(self)->tp_name);
+    return NULL;
 }
 
 /*[clinic input]
diff --git a/Modules/_functoolsmodule.c b/Modules/_functoolsmodule.c
index 1aa4571..d785c49 100644
--- a/Modules/_functoolsmodule.c
+++ b/Modules/_functoolsmodule.c
@@ -203,40 +203,45 @@ static PyGetSetDef partial_getsetlist[] = {
 static PyObject *
 partial_repr(partialobject *pto)
 {
-    PyObject *result;
+    PyObject *result = NULL;
     PyObject *arglist;
-    PyObject *tmp;
     Py_ssize_t i, n;
     PyObject *key, *value;
+    int status;
 
-    arglist = PyUnicode_FromString("");
-    if (arglist == NULL) {
-        return NULL;
+    status = Py_ReprEnter((PyObject *)pto);
+    if (status != 0) {
+        if (status < 0)
+            return NULL;
+        return PyUnicode_FromFormat("%s(...)", Py_TYPE(pto)->tp_name);
     }
+
+    arglist = PyUnicode_FromString("");
+    if (arglist == NULL)
+        goto done;
     /* Pack positional arguments */
     assert (PyTuple_Check(pto->args));
     n = PyTuple_GET_SIZE(pto->args);
     for (i = 0; i < n; i++) {
-        tmp = PyUnicode_FromFormat("%U, %R", arglist,
-                                   PyTuple_GET_ITEM(pto->args, i));
-        Py_DECREF(arglist);
-        if (tmp == NULL)
-            return NULL;
-        arglist = tmp;
+        Py_SETREF(arglist, PyUnicode_FromFormat("%U, %R", arglist,
+                                        PyTuple_GET_ITEM(pto->args, i)));
+        if (arglist == NULL)
+            goto done;
     }
     /* Pack keyword arguments */
     assert (PyDict_Check(pto->kw));
     for (i = 0; PyDict_Next(pto->kw, &i, &key, &value);) {
-        tmp = PyUnicode_FromFormat("%U, %U=%R", arglist,
-                                    key, value);
-        Py_DECREF(arglist);
-        if (tmp == NULL)
-            return NULL;
-        arglist = tmp;
+        Py_SETREF(arglist, PyUnicode_FromFormat("%U, %U=%R", arglist,
+                                                key, value));
+        if (arglist == NULL)
+            goto done;
     }
     result = PyUnicode_FromFormat("%s(%R%U)", Py_TYPE(pto)->tp_name,
                                   pto->fn, arglist);
     Py_DECREF(arglist);
+
+ done:
+    Py_ReprLeave((PyObject *)pto);
     return result;
 }
 
diff --git a/Modules/_sqlite/connection.c b/Modules/_sqlite/connection.c
index 7570624..6aa4764 100644
--- a/Modules/_sqlite/connection.c
+++ b/Modules/_sqlite/connection.c
@@ -164,6 +164,10 @@ int pysqlite_connection_init(pysqlite_Connection* self, PyObject* args, PyObject
 #ifdef WITH_THREAD
     self->thread_ident = PyThread_get_thread_ident();
 #endif
+    if (!check_same_thread && sqlite3_libversion_number() < 3003001) {
+        PyErr_SetString(pysqlite_NotSupportedError, "shared connections not available");
+        return -1;
+    }
     self->check_same_thread = check_same_thread;
 
     self->function_pinboard = PyDict_New();
diff --git a/Modules/_sqlite/module.h b/Modules/_sqlite/module.h
index b51724b..0fb5a55 100644
--- a/Modules/_sqlite/module.h
+++ b/Modules/_sqlite/module.h
@@ -42,7 +42,7 @@ extern PyObject* pysqlite_NotSupportedError;
 extern PyObject* time_time;
 extern PyObject* time_sleep;
 
-/* A dictionary, mapping colum types (INTEGER, VARCHAR, etc.) to converter
+/* A dictionary, mapping column types (INTEGER, VARCHAR, etc.) to converter
  * functions, that convert the SQL value to the appropriate Python value.
  * The key is uppercase.
  */
diff --git a/PC/launcher.c b/PC/launcher.c
index db5226e..40d4cb5 100644
--- a/PC/launcher.c
+++ b/PC/launcher.c
@@ -1081,7 +1081,7 @@ static PYC_MAGIC magic_values[] = {
     { 3160, 3180, L"3.2" },
     { 3190, 3230, L"3.3" },
     { 3250, 3310, L"3.4" },
-    { 3320, 3350, L"3.5" },
+    { 3320, 3351, L"3.5" },
     { 3360, 3361, L"3.6" },
     { 0 }
 };
diff --git a/Python/compile.c b/Python/compile.c
index 1e720ea..0c4a6c8 100644
--- a/Python/compile.c
+++ b/Python/compile.c
@@ -3262,7 +3262,7 @@ compiler_call_helper(struct compiler *c,
         code |= 2;
         if (nsubkwargs > 1) {
             /* Pack it all up */
-            int function_pos = n + (code & 1) + nkw + 1;
+            int function_pos = n + (code & 1) + 2 * nkw + 1;
             ADDOP_I(c, BUILD_MAP_UNPACK_WITH_CALL, nsubkwargs | (function_pos << 8));
         }
     }
diff --git a/Python/importlib_external.h b/Python/importlib_external.h
index 47f5c62..a871f54 100644
--- a/Python/importlib_external.h
+++ b/Python/importlib_external.h
@@ -259,7 +259,7 @@ const unsigned char _Py_M__importlib_external[] = {
     0,0,114,5,0,0,0,218,13,95,119,114,105,116,101,95,
     97,116,111,109,105,99,99,0,0,0,115,26,0,0,0,0,
     5,24,1,9,1,33,1,3,3,21,1,20,1,20,1,13,
-    1,3,1,17,1,13,1,5,1,114,55,0,0,0,105,22,
+    1,3,1,17,1,13,1,5,1,114,55,0,0,0,105,23,
     13,0,0,233,2,0,0,0,114,13,0,0,0,115,2,0,
     0,0,13,10,90,11,95,95,112,121,99,97,99,104,101,95,
     95,122,4,111,112,116,45,122,3,46,112,121,122,4,46,112,
@@ -369,7 +369,7 @@ const unsigned char _Py_M__importlib_external[] = {
     116,97,103,90,15,97,108,109,111,115,116,95,102,105,108,101,
     110,97,109,101,114,4,0,0,0,114,4,0,0,0,114,5,
     0,0,0,218,17,99,97,99,104,101,95,102,114,111,109,95,
-    115,111,117,114,99,101,246,0,0,0,115,46,0,0,0,0,
+    115,111,117,114,99,101,247,0,0,0,115,46,0,0,0,0,
     18,12,1,9,1,7,1,12,1,6,1,12,1,18,1,18,
     1,24,1,12,1,12,1,12,1,36,1,12,1,18,1,9,
     2,12,1,12,1,12,1,12,1,21,1,21,1,114,79,0,
@@ -448,7 +448,7 @@ const unsigned char _Py_M__importlib_external[] = {
     95,108,101,118,101,108,90,13,98,97,115,101,95,102,105,108,
     101,110,97,109,101,114,4,0,0,0,114,4,0,0,0,114,
     5,0,0,0,218,17,115,111,117,114,99,101,95,102,114,111,
-    109,95,99,97,99,104,101,34,1,0,0,115,44,0,0,0,
+    109,95,99,97,99,104,101,35,1,0,0,115,44,0,0,0,
     0,9,18,1,12,1,18,1,18,1,12,1,9,1,15,1,
     15,1,12,1,9,1,15,1,12,1,22,1,15,1,9,1,
     12,1,22,1,12,1,9,1,12,1,19,1,114,85,0,0,
@@ -486,7 +486,7 @@ const unsigned char _Py_M__importlib_external[] = {
     115,105,111,110,218,11,115,111,117,114,99,101,95,112,97,116,
     104,114,4,0,0,0,114,4,0,0,0,114,5,0,0,0,
     218,15,95,103,101,116,95,115,111,117,114,99,101,102,105,108,
-    101,67,1,0,0,115,20,0,0,0,0,7,18,1,4,1,
+    101,68,1,0,0,115,20,0,0,0,0,7,18,1,4,1,
     24,1,35,1,4,1,3,1,16,1,19,1,21,1,114,91,
     0,0,0,99,1,0,0,0,0,0,0,0,1,0,0,0,
     11,0,0,0,67,0,0,0,115,92,0,0,0,124,0,0,
@@ -500,7 +500,7 @@ const unsigned char _Py_M__importlib_external[] = {
     84,0,0,0,114,79,0,0,0,114,66,0,0,0,114,74,
     0,0,0,41,1,218,8,102,105,108,101,110,97,109,101,114,
     4,0,0,0,114,4,0,0,0,114,5,0,0,0,218,11,
-    95,103,101,116,95,99,97,99,104,101,100,86,1,0,0,115,
+    95,103,101,116,95,99,97,99,104,101,100,87,1,0,0,115,
     16,0,0,0,0,1,21,1,3,1,14,1,13,1,8,1,
     21,1,4,2,114,95,0,0,0,99,1,0,0,0,0,0,
     0,0,2,0,0,0,11,0,0,0,67,0,0,0,115,60,
@@ -515,7 +515,7 @@ const unsigned char _Py_M__importlib_external[] = {
     41,3,114,39,0,0,0,114,41,0,0,0,114,40,0,0,
     0,41,2,114,35,0,0,0,114,42,0,0,0,114,4,0,
     0,0,114,4,0,0,0,114,5,0,0,0,218,10,95,99,
-    97,108,99,95,109,111,100,101,98,1,0,0,115,12,0,0,
+    97,108,99,95,109,111,100,101,99,1,0,0,115,12,0,0,
     0,0,2,3,1,19,1,13,1,11,3,10,1,114,97,0,
     0,0,218,9,118,101,114,98,111,115,105,116,121,114,29,0,
     0,0,99,1,0,0,0,1,0,0,0,3,0,0,0,4,
@@ -536,7 +536,7 @@ const unsigned char _Py_M__importlib_external[] = {
     218,6,115,116,100,101,114,114,41,3,114,75,0,0,0,114,
     98,0,0,0,218,4,97,114,103,115,114,4,0,0,0,114,
     4,0,0,0,114,5,0,0,0,218,16,95,118,101,114,98,
-    111,115,101,95,109,101,115,115,97,103,101,110,1,0,0,115,
+    111,115,101,95,109,101,115,115,97,103,101,111,1,0,0,115,
     8,0,0,0,0,2,18,1,15,1,10,1,114,105,0,0,
     0,99,1,0,0,0,0,0,0,0,3,0,0,0,11,0,
     0,0,3,0,0,0,115,84,0,0,0,100,1,0,135,0,
@@ -576,7 +576,7 @@ const unsigned char _Py_M__importlib_external[] = {
     0,0,90,6,107,119,97,114,103,115,41,1,218,6,109,101,
     116,104,111,100,114,4,0,0,0,114,5,0,0,0,218,19,
     95,99,104,101,99,107,95,110,97,109,101,95,119,114,97,112,
-    112,101,114,126,1,0,0,115,12,0,0,0,0,1,12,1,
+    112,101,114,127,1,0,0,115,12,0,0,0,0,1,12,1,
     12,1,15,1,6,1,25,1,122,40,95,99,104,101,99,107,
     95,110,97,109,101,46,60,108,111,99,97,108,115,62,46,95,
     99,104,101,99,107,95,110,97,109,101,95,119,114,97,112,112,
@@ -595,7 +595,7 @@ const unsigned char _Py_M__importlib_external[] = {
     116,97,116,116,114,218,8,95,95,100,105,99,116,95,95,218,
     6,117,112,100,97,116,101,41,3,90,3,110,101,119,90,3,
     111,108,100,114,52,0,0,0,114,4,0,0,0,114,4,0,
-    0,0,114,5,0,0,0,218,5,95,119,114,97,112,137,1,
+    0,0,114,5,0,0,0,218,5,95,119,114,97,112,138,1,
     0,0,115,8,0,0,0,0,1,25,1,15,1,29,1,122,
     26,95,99,104,101,99,107,95,110,97,109,101,46,60,108,111,
     99,97,108,115,62,46,95,119,114,97,112,41,3,218,10,95,
@@ -603,7 +603,7 @@ const unsigned char _Py_M__importlib_external[] = {
     78,97,109,101,69,114,114,111,114,41,3,114,109,0,0,0,
     114,110,0,0,0,114,120,0,0,0,114,4,0,0,0,41,
     1,114,109,0,0,0,114,5,0,0,0,218,11,95,99,104,
-    101,99,107,95,110,97,109,101,118,1,0,0,115,14,0,0,
+    101,99,107,95,110,97,109,101,119,1,0,0,115,14,0,0,
     0,0,8,21,7,3,1,13,1,13,2,17,5,13,1,114,
     123,0,0,0,99,2,0,0,0,0,0,0,0,5,0,0,
     0,4,0,0,0,67,0,0,0,115,84,0,0,0,124,0,
@@ -633,7 +633,7 @@ const unsigned char _Py_M__importlib_external[] = {
     218,8,112,111,114,116,105,111,110,115,218,3,109,115,103,114,
     4,0,0,0,114,4,0,0,0,114,5,0,0,0,218,17,
     95,102,105,110,100,95,109,111,100,117,108,101,95,115,104,105,
-    109,146,1,0,0,115,10,0,0,0,0,10,21,1,24,1,
+    109,147,1,0,0,115,10,0,0,0,0,10,21,1,24,1,
     6,1,29,1,114,130,0,0,0,99,4,0,0,0,0,0,
     0,0,11,0,0,0,19,0,0,0,67,0,0,0,115,240,
     1,0,0,105,0,0,125,4,0,124,2,0,100,1,0,107,
@@ -718,7 +718,7 @@ const unsigned char _Py_M__importlib_external[] = {
     109,101,218,11,115,111,117,114,99,101,95,115,105,122,101,114,
     4,0,0,0,114,4,0,0,0,114,5,0,0,0,218,25,
     95,118,97,108,105,100,97,116,101,95,98,121,116,101,99,111,
-    100,101,95,104,101,97,100,101,114,163,1,0,0,115,76,0,
+    100,101,95,104,101,97,100,101,114,164,1,0,0,115,76,0,
     0,0,0,11,6,1,12,1,13,3,6,1,12,1,10,1,
     16,1,16,1,16,1,12,1,18,1,13,1,18,1,18,1,
     15,1,13,1,15,1,18,1,15,1,13,1,12,1,12,1,
@@ -749,7 +749,7 @@ const unsigned char _Py_M__importlib_external[] = {
     114,106,0,0,0,114,89,0,0,0,114,90,0,0,0,218,
     4,99,111,100,101,114,4,0,0,0,114,4,0,0,0,114,
     5,0,0,0,218,17,95,99,111,109,112,105,108,101,95,98,
-    121,116,101,99,111,100,101,218,1,0,0,115,16,0,0,0,
+    121,116,101,99,111,100,101,219,1,0,0,115,16,0,0,0,
     0,2,15,1,15,1,13,1,12,1,16,1,4,2,18,1,
     114,147,0,0,0,114,59,0,0,0,99,3,0,0,0,0,
     0,0,0,4,0,0,0,3,0,0,0,67,0,0,0,115,
@@ -769,7 +769,7 @@ const unsigned char _Py_M__importlib_external[] = {
     4,114,146,0,0,0,114,133,0,0,0,114,140,0,0,0,
     114,53,0,0,0,114,4,0,0,0,114,4,0,0,0,114,
     5,0,0,0,218,17,95,99,111,100,101,95,116,111,95,98,
-    121,116,101,99,111,100,101,230,1,0,0,115,10,0,0,0,
+    121,116,101,99,111,100,101,231,1,0,0,115,10,0,0,0,
     0,3,12,1,19,1,19,1,22,1,114,150,0,0,0,99,
     1,0,0,0,0,0,0,0,5,0,0,0,4,0,0,0,
     67,0,0,0,115,89,0,0,0,100,1,0,100,2,0,108,
@@ -798,7 +798,7 @@ const unsigned char _Py_M__importlib_external[] = {
     100,105,110,103,90,15,110,101,119,108,105,110,101,95,100,101,
     99,111,100,101,114,114,4,0,0,0,114,4,0,0,0,114,
     5,0,0,0,218,13,100,101,99,111,100,101,95,115,111,117,
-    114,99,101,240,1,0,0,115,10,0,0,0,0,5,12,1,
+    114,99,101,241,1,0,0,115,10,0,0,0,0,5,12,1,
     18,1,15,1,18,1,114,155,0,0,0,114,127,0,0,0,
     218,26,115,117,98,109,111,100,117,108,101,95,115,101,97,114,
     99,104,95,108,111,99,97,116,105,111,110,115,99,2,0,0,
@@ -863,7 +863,7 @@ const unsigned char _Py_M__importlib_external[] = {
     159,0,0,0,90,7,100,105,114,110,97,109,101,114,4,0,
     0,0,114,4,0,0,0,114,5,0,0,0,218,23,115,112,
     101,99,95,102,114,111,109,95,102,105,108,101,95,108,111,99,
-    97,116,105,111,110,1,2,0,0,115,60,0,0,0,0,12,
+    97,116,105,111,110,2,2,0,0,115,60,0,0,0,0,12,
     12,4,6,1,15,2,3,1,19,1,13,1,5,8,24,1,
     9,3,12,1,22,1,21,1,15,1,9,1,5,2,4,3,
     12,2,15,1,3,1,19,1,13,1,5,2,6,1,12,2,
@@ -903,7 +903,7 @@ const unsigned char _Py_M__importlib_external[] = {
     79,67,65,76,95,77,65,67,72,73,78,69,41,2,218,3,
     99,108,115,218,3,107,101,121,114,4,0,0,0,114,4,0,
     0,0,114,5,0,0,0,218,14,95,111,112,101,110,95,114,
-    101,103,105,115,116,114,121,79,2,0,0,115,8,0,0,0,
+    101,103,105,115,116,114,121,80,2,0,0,115,8,0,0,0,
     0,2,3,1,23,1,13,1,122,36,87,105,110,100,111,119,
     115,82,101,103,105,115,116,114,121,70,105,110,100,101,114,46,
     95,111,112,101,110,95,114,101,103,105,115,116,114,121,99,2,
@@ -930,7 +930,7 @@ const unsigned char _Py_M__importlib_external[] = {
     171,0,0,0,90,4,104,107,101,121,218,8,102,105,108,101,
     112,97,116,104,114,4,0,0,0,114,4,0,0,0,114,5,
     0,0,0,218,16,95,115,101,97,114,99,104,95,114,101,103,
-    105,115,116,114,121,86,2,0,0,115,22,0,0,0,0,2,
+    105,115,116,114,121,87,2,0,0,115,22,0,0,0,0,2,
     9,1,12,2,9,1,15,1,22,1,3,1,18,1,29,1,
     13,1,9,1,122,38,87,105,110,100,111,119,115,82,101,103,
     105,115,116,114,121,70,105,110,100,101,114,46,95,115,101,97,
@@ -954,7 +954,7 @@ const unsigned char _Py_M__importlib_external[] = {
     114,35,0,0,0,218,6,116,97,114,103,101,116,114,177,0,
     0,0,114,127,0,0,0,114,166,0,0,0,114,164,0,0,
     0,114,4,0,0,0,114,4,0,0,0,114,5,0,0,0,
-    218,9,102,105,110,100,95,115,112,101,99,101,2,0,0,115,
+    218,9,102,105,110,100,95,115,112,101,99,102,2,0,0,115,
     26,0,0,0,0,2,15,1,12,1,4,1,3,1,14,1,
     13,1,9,1,22,1,21,1,9,1,15,1,9,1,122,31,
     87,105,110,100,111,119,115,82,101,103,105,115,116,114,121,70,
@@ -974,7 +974,7 @@ const unsigned char _Py_M__importlib_external[] = {
     0,0,0,41,4,114,170,0,0,0,114,126,0,0,0,114,
     35,0,0,0,114,164,0,0,0,114,4,0,0,0,114,4,
     0,0,0,114,5,0,0,0,218,11,102,105,110,100,95,109,
-    111,100,117,108,101,117,2,0,0,115,8,0,0,0,0,7,
+    111,100,117,108,101,118,2,0,0,115,8,0,0,0,0,7,
     18,1,12,1,7,2,122,33,87,105,110,100,111,119,115,82,
     101,103,105,115,116,114,121,70,105,110,100,101,114,46,102,105,
     110,100,95,109,111,100,117,108,101,41,12,114,112,0,0,0,
@@ -983,7 +983,7 @@ const unsigned char _Py_M__importlib_external[] = {
     99,108,97,115,115,109,101,116,104,111,100,114,172,0,0,0,
     114,178,0,0,0,114,181,0,0,0,114,182,0,0,0,114,
     4,0,0,0,114,4,0,0,0,114,4,0,0,0,114,5,
-    0,0,0,114,168,0,0,0,67,2,0,0,115,20,0,0,
+    0,0,0,114,168,0,0,0,68,2,0,0,115,20,0,0,
     0,12,2,6,3,6,3,6,2,6,2,18,7,18,15,3,
     1,21,15,3,1,114,168,0,0,0,99,0,0,0,0,0,
     0,0,0,0,0,0,0,2,0,0,0,64,0,0,0,115,
@@ -1021,7 +1021,7 @@ const unsigned char _Py_M__importlib_external[] = {
     0,0,0,114,94,0,0,0,90,13,102,105,108,101,110,97,
     109,101,95,98,97,115,101,90,9,116,97,105,108,95,110,97,
     109,101,114,4,0,0,0,114,4,0,0,0,114,5,0,0,
-    0,114,159,0,0,0,136,2,0,0,115,8,0,0,0,0,
+    0,114,159,0,0,0,137,2,0,0,115,8,0,0,0,0,
     3,25,1,22,1,19,1,122,24,95,76,111,97,100,101,114,
     66,97,115,105,99,115,46,105,115,95,112,97,99,107,97,103,
     101,99,2,0,0,0,0,0,0,0,2,0,0,0,1,0,
@@ -1031,7 +1031,7 @@ const unsigned char _Py_M__importlib_external[] = {
     117,108,101,32,99,114,101,97,116,105,111,110,46,78,114,4,
     0,0,0,41,2,114,108,0,0,0,114,164,0,0,0,114,
     4,0,0,0,114,4,0,0,0,114,5,0,0,0,218,13,
-    99,114,101,97,116,101,95,109,111,100,117,108,101,144,2,0,
+    99,114,101,97,116,101,95,109,111,100,117,108,101,145,2,0,
     0,115,0,0,0,0,122,27,95,76,111,97,100,101,114,66,
     97,115,105,99,115,46,99,114,101,97,116,101,95,109,111,100,
     117,108,101,99,2,0,0,0,0,0,0,0,3,0,0,0,
@@ -1053,7 +1053,7 @@ const unsigned char _Py_M__importlib_external[] = {
     0,41,3,114,108,0,0,0,218,6,109,111,100,117,108,101,
     114,146,0,0,0,114,4,0,0,0,114,4,0,0,0,114,
     5,0,0,0,218,11,101,120,101,99,95,109,111,100,117,108,
-    101,147,2,0,0,115,10,0,0,0,0,2,18,1,12,1,
+    101,148,2,0,0,115,10,0,0,0,0,2,18,1,12,1,
     9,1,15,1,122,25,95,76,111,97,100,101,114,66,97,115,
     105,99,115,46,101,120,101,99,95,109,111,100,117,108,101,99,
     2,0,0,0,0,0,0,0,2,0,0,0,3,0,0,0,
@@ -1062,14 +1062,14 @@ const unsigned char _Py_M__importlib_external[] = {
     0,0,0,218,17,95,108,111,97,100,95,109,111,100,117,108,
     101,95,115,104,105,109,41,2,114,108,0,0,0,114,126,0,
     0,0,114,4,0,0,0,114,4,0,0,0,114,5,0,0,
-    0,218,11,108,111,97,100,95,109,111,100,117,108,101,155,2,
+    0,218,11,108,111,97,100,95,109,111,100,117,108,101,156,2,
     0,0,115,2,0,0,0,0,1,122,25,95,76,111,97,100,
     101,114,66,97,115,105,99,115,46,108,111,97,100,95,109,111,
     100,117,108,101,78,41,8,114,112,0,0,0,114,111,0,0,
     0,114,113,0,0,0,114,114,0,0,0,114,159,0,0,0,
     114,186,0,0,0,114,191,0,0,0,114,193,0,0,0,114,
     4,0,0,0,114,4,0,0,0,114,4,0,0,0,114,5,
-    0,0,0,114,184,0,0,0,131,2,0,0,115,10,0,0,
+    0,0,0,114,184,0,0,0,132,2,0,0,115,10,0,0,
     0,12,3,6,2,12,8,12,3,12,8,114,184,0,0,0,
     99,0,0,0,0,0,0,0,0,0,0,0,0,4,0,0,
     0,64,0,0,0,115,106,0,0,0,101,0,0,90,1,0,
@@ -1097,7 +1097,7 @@ const unsigned char _Py_M__importlib_external[] = {
     1,218,7,73,79,69,114,114,111,114,41,2,114,108,0,0,
     0,114,35,0,0,0,114,4,0,0,0,114,4,0,0,0,
     114,5,0,0,0,218,10,112,97,116,104,95,109,116,105,109,
-    101,161,2,0,0,115,2,0,0,0,0,6,122,23,83,111,
+    101,162,2,0,0,115,2,0,0,0,0,6,122,23,83,111,
     117,114,99,101,76,111,97,100,101,114,46,112,97,116,104,95,
     109,116,105,109,101,99,2,0,0,0,0,0,0,0,2,0,
     0,0,3,0,0,0,67,0,0,0,115,19,0,0,0,100,
@@ -1132,7 +1132,7 @@ const unsigned char _Py_M__importlib_external[] = {
     32,32,32,114,133,0,0,0,41,1,114,196,0,0,0,41,
     2,114,108,0,0,0,114,35,0,0,0,114,4,0,0,0,
     114,4,0,0,0,114,5,0,0,0,218,10,112,97,116,104,
-    95,115,116,97,116,115,169,2,0,0,115,2,0,0,0,0,
+    95,115,116,97,116,115,170,2,0,0,115,2,0,0,0,0,
     11,122,23,83,111,117,114,99,101,76,111,97,100,101,114,46,
     112,97,116,104,95,115,116,97,116,115,99,4,0,0,0,0,
     0,0,0,4,0,0,0,3,0,0,0,67,0,0,0,115,
@@ -1156,7 +1156,7 @@ const unsigned char _Py_M__importlib_external[] = {
     90,0,0,0,90,10,99,97,99,104,101,95,112,97,116,104,
     114,53,0,0,0,114,4,0,0,0,114,4,0,0,0,114,
     5,0,0,0,218,15,95,99,97,99,104,101,95,98,121,116,
-    101,99,111,100,101,182,2,0,0,115,2,0,0,0,0,8,
+    101,99,111,100,101,183,2,0,0,115,2,0,0,0,0,8,
     122,28,83,111,117,114,99,101,76,111,97,100,101,114,46,95,
     99,97,99,104,101,95,98,121,116,101,99,111,100,101,99,3,
     0,0,0,0,0,0,0,3,0,0,0,1,0,0,0,67,
@@ -1173,7 +1173,7 @@ const unsigned char _Py_M__importlib_external[] = {
     32,32,32,32,32,32,78,114,4,0,0,0,41,3,114,108,
     0,0,0,114,35,0,0,0,114,53,0,0,0,114,4,0,
     0,0,114,4,0,0,0,114,5,0,0,0,114,198,0,0,
-    0,192,2,0,0,115,0,0,0,0,122,21,83,111,117,114,
+    0,193,2,0,0,115,0,0,0,0,122,21,83,111,117,114,
     99,101,76,111,97,100,101,114,46,115,101,116,95,100,97,116,
     97,99,2,0,0,0,0,0,0,0,5,0,0,0,16,0,
     0,0,67,0,0,0,115,105,0,0,0,124,0,0,106,0,
@@ -1195,7 +1195,7 @@ const unsigned char _Py_M__importlib_external[] = {
     0,0,114,126,0,0,0,114,35,0,0,0,114,153,0,0,
     0,218,3,101,120,99,114,4,0,0,0,114,4,0,0,0,
     114,5,0,0,0,218,10,103,101,116,95,115,111,117,114,99,
-    101,199,2,0,0,115,14,0,0,0,0,2,15,1,3,1,
+    101,200,2,0,0,115,14,0,0,0,0,2,15,1,3,1,
     19,1,18,1,9,1,31,1,122,23,83,111,117,114,99,101,
     76,111,97,100,101,114,46,103,101,116,95,115,111,117,114,99,
     101,218,9,95,111,112,116,105,109,105,122,101,114,29,0,0,
@@ -1217,7 +1217,7 @@ const unsigned char _Py_M__importlib_external[] = {
     101,41,4,114,108,0,0,0,114,53,0,0,0,114,35,0,
     0,0,114,203,0,0,0,114,4,0,0,0,114,4,0,0,
     0,114,5,0,0,0,218,14,115,111,117,114,99,101,95,116,
-    111,95,99,111,100,101,209,2,0,0,115,4,0,0,0,0,
+    111,95,99,111,100,101,210,2,0,0,115,4,0,0,0,0,
     5,21,1,122,27,83,111,117,114,99,101,76,111,97,100,101,
     114,46,115,111,117,114,99,101,95,116,111,95,99,111,100,101,
     99,2,0,0,0,0,0,0,0,10,0,0,0,43,0,0,
@@ -1278,7 +1278,7 @@ const unsigned char _Py_M__importlib_external[] = {
     98,121,116,101,115,95,100,97,116,97,114,153,0,0,0,90,
     11,99,111,100,101,95,111,98,106,101,99,116,114,4,0,0,
     0,114,4,0,0,0,114,5,0,0,0,114,187,0,0,0,
-    217,2,0,0,115,78,0,0,0,0,7,15,1,6,1,3,
+    218,2,0,0,115,78,0,0,0,0,7,15,1,6,1,3,
     1,16,1,13,1,11,2,3,1,19,1,13,1,5,2,16,
     1,3,1,19,1,13,1,5,2,3,1,9,1,12,1,13,
     1,19,1,5,2,9,1,7,1,15,1,6,1,7,1,15,
@@ -1290,7 +1290,7 @@ const unsigned char _Py_M__importlib_external[] = {
     199,0,0,0,114,198,0,0,0,114,202,0,0,0,114,206,
     0,0,0,114,187,0,0,0,114,4,0,0,0,114,4,0,
     0,0,114,4,0,0,0,114,5,0,0,0,114,194,0,0,
-    0,159,2,0,0,115,14,0,0,0,12,2,12,8,12,13,
+    0,160,2,0,0,115,14,0,0,0,12,2,12,8,12,13,
     12,10,12,7,12,10,18,8,114,194,0,0,0,99,0,0,
     0,0,0,0,0,0,0,0,0,0,4,0,0,0,0,0,
     0,0,115,112,0,0,0,101,0,0,90,1,0,100,0,0,
@@ -1318,7 +1318,7 @@ const unsigned char _Py_M__importlib_external[] = {
     32,32,32,32,32,32,102,105,110,100,101,114,46,78,41,2,
     114,106,0,0,0,114,35,0,0,0,41,3,114,108,0,0,
     0,114,126,0,0,0,114,35,0,0,0,114,4,0,0,0,
-    114,4,0,0,0,114,5,0,0,0,114,185,0,0,0,18,
+    114,4,0,0,0,114,5,0,0,0,114,185,0,0,0,19,
     3,0,0,115,4,0,0,0,0,3,9,1,122,19,70,105,
     108,101,76,111,97,100,101,114,46,95,95,105,110,105,116,95,
     95,99,2,0,0,0,0,0,0,0,2,0,0,0,2,0,
@@ -1328,7 +1328,7 @@ const unsigned char _Py_M__importlib_external[] = {
     41,2,218,9,95,95,99,108,97,115,115,95,95,114,118,0,
     0,0,41,2,114,108,0,0,0,218,5,111,116,104,101,114,
     114,4,0,0,0,114,4,0,0,0,114,5,0,0,0,218,
-    6,95,95,101,113,95,95,24,3,0,0,115,4,0,0,0,
+    6,95,95,101,113,95,95,25,3,0,0,115,4,0,0,0,
     0,1,18,1,122,17,70,105,108,101,76,111,97,100,101,114,
     46,95,95,101,113,95,95,99,1,0,0,0,0,0,0,0,
     1,0,0,0,3,0,0,0,67,0,0,0,115,26,0,0,
@@ -1337,7 +1337,7 @@ const unsigned char _Py_M__importlib_external[] = {
     218,4,104,97,115,104,114,106,0,0,0,114,35,0,0,0,
     41,1,114,108,0,0,0,114,4,0,0,0,114,4,0,0,
     0,114,5,0,0,0,218,8,95,95,104,97,115,104,95,95,
-    28,3,0,0,115,2,0,0,0,0,1,122,19,70,105,108,
+    29,3,0,0,115,2,0,0,0,0,1,122,19,70,105,108,
     101,76,111,97,100,101,114,46,95,95,104,97,115,104,95,95,
     99,2,0,0,0,0,0,0,0,2,0,0,0,3,0,0,
     0,3,0,0,0,115,22,0,0,0,116,0,0,116,1,0,
@@ -1351,7 +1351,7 @@ const unsigned char _Py_M__importlib_external[] = {
     32,32,32,32,32,32,32,32,41,3,218,5,115,117,112,101,
     114,114,210,0,0,0,114,193,0,0,0,41,2,114,108,0,
     0,0,114,126,0,0,0,41,1,114,211,0,0,0,114,4,
-    0,0,0,114,5,0,0,0,114,193,0,0,0,31,3,0,
+    0,0,0,114,5,0,0,0,114,193,0,0,0,32,3,0,
     0,115,2,0,0,0,0,10,122,22,70,105,108,101,76,111,
     97,100,101,114,46,108,111,97,100,95,109,111,100,117,108,101,
     99,2,0,0,0,0,0,0,0,2,0,0,0,1,0,0,
@@ -1362,7 +1362,7 @@ const unsigned char _Py_M__importlib_external[] = {
     32,98,121,32,116,104,101,32,102,105,110,100,101,114,46,41,
     1,114,35,0,0,0,41,2,114,108,0,0,0,114,126,0,
     0,0,114,4,0,0,0,114,4,0,0,0,114,5,0,0,
-    0,114,157,0,0,0,43,3,0,0,115,2,0,0,0,0,
+    0,114,157,0,0,0,44,3,0,0,115,2,0,0,0,0,
     3,122,23,70,105,108,101,76,111,97,100,101,114,46,103,101,
     116,95,102,105,108,101,110,97,109,101,99,2,0,0,0,0,
     0,0,0,3,0,0,0,9,0,0,0,67,0,0,0,115,
@@ -1375,14 +1375,14 @@ const unsigned char _Py_M__importlib_external[] = {
     49,0,0,0,114,50,0,0,0,90,4,114,101,97,100,41,
     3,114,108,0,0,0,114,35,0,0,0,114,54,0,0,0,
     114,4,0,0,0,114,4,0,0,0,114,5,0,0,0,114,
-    200,0,0,0,48,3,0,0,115,4,0,0,0,0,2,21,
+    200,0,0,0,49,3,0,0,115,4,0,0,0,0,2,21,
     1,122,19,70,105,108,101,76,111,97,100,101,114,46,103,101,
     116,95,100,97,116,97,41,11,114,112,0,0,0,114,111,0,
     0,0,114,113,0,0,0,114,114,0,0,0,114,185,0,0,
     0,114,213,0,0,0,114,215,0,0,0,114,123,0,0,0,
     114,193,0,0,0,114,157,0,0,0,114,200,0,0,0,114,
     4,0,0,0,114,4,0,0,0,41,1,114,211,0,0,0,
-    114,5,0,0,0,114,210,0,0,0,13,3,0,0,115,14,
+    114,5,0,0,0,114,210,0,0,0,14,3,0,0,115,14,
     0,0,0,12,3,6,2,12,6,12,4,12,3,24,12,18,
     5,114,210,0,0,0,99,0,0,0,0,0,0,0,0,0,
     0,0,0,4,0,0,0,64,0,0,0,115,64,0,0,0,
@@ -1405,7 +1405,7 @@ const unsigned char _Py_M__importlib_external[] = {
     3,114,39,0,0,0,218,8,115,116,95,109,116,105,109,101,
     90,7,115,116,95,115,105,122,101,41,3,114,108,0,0,0,
     114,35,0,0,0,114,208,0,0,0,114,4,0,0,0,114,
-    4,0,0,0,114,5,0,0,0,114,197,0,0,0,58,3,
+    4,0,0,0,114,5,0,0,0,114,197,0,0,0,59,3,
     0,0,115,4,0,0,0,0,2,12,1,122,27,83,111,117,
     114,99,101,70,105,108,101,76,111,97,100,101,114,46,112,97,
     116,104,95,115,116,97,116,115,99,4,0,0,0,0,0,0,
@@ -1416,7 +1416,7 @@ const unsigned char _Py_M__importlib_external[] = {
     114,97,0,0,0,114,198,0,0,0,41,5,114,108,0,0,
     0,114,90,0,0,0,114,89,0,0,0,114,53,0,0,0,
     114,42,0,0,0,114,4,0,0,0,114,4,0,0,0,114,
-    5,0,0,0,114,199,0,0,0,63,3,0,0,115,4,0,
+    5,0,0,0,114,199,0,0,0,64,3,0,0,115,4,0,
     0,0,0,2,12,1,122,32,83,111,117,114,99,101,70,105,
     108,101,76,111,97,100,101,114,46,95,99,97,99,104,101,95,
     98,121,116,101,99,111,100,101,114,220,0,0,0,105,182,1,
@@ -1454,7 +1454,7 @@ const unsigned char _Py_M__importlib_external[] = {
     53,0,0,0,114,220,0,0,0,218,6,112,97,114,101,110,
     116,114,94,0,0,0,114,27,0,0,0,114,23,0,0,0,
     114,201,0,0,0,114,4,0,0,0,114,4,0,0,0,114,
-    5,0,0,0,114,198,0,0,0,68,3,0,0,115,38,0,
+    5,0,0,0,114,198,0,0,0,69,3,0,0,115,38,0,
     0,0,0,2,18,1,6,2,22,1,18,1,17,2,19,1,
     15,1,3,1,17,1,13,2,7,1,18,3,16,1,27,1,
     3,1,16,1,17,1,18,2,122,25,83,111,117,114,99,101,
@@ -1463,7 +1463,7 @@ const unsigned char _Py_M__importlib_external[] = {
     114,113,0,0,0,114,114,0,0,0,114,197,0,0,0,114,
     199,0,0,0,114,198,0,0,0,114,4,0,0,0,114,4,
     0,0,0,114,4,0,0,0,114,5,0,0,0,114,218,0,
-    0,0,54,3,0,0,115,8,0,0,0,12,2,6,2,12,
+    0,0,55,3,0,0,115,8,0,0,0,12,2,6,2,12,
     5,12,5,114,218,0,0,0,99,0,0,0,0,0,0,0,
     0,0,0,0,0,2,0,0,0,64,0,0,0,115,46,0,
     0,0,101,0,0,90,1,0,100,0,0,90,2,0,100,1,
@@ -1485,7 +1485,7 @@ const unsigned char _Py_M__importlib_external[] = {
     114,147,0,0,0,41,5,114,108,0,0,0,114,126,0,0,
     0,114,35,0,0,0,114,53,0,0,0,114,209,0,0,0,
     114,4,0,0,0,114,4,0,0,0,114,5,0,0,0,114,
-    187,0,0,0,101,3,0,0,115,8,0,0,0,0,1,15,
+    187,0,0,0,102,3,0,0,115,8,0,0,0,0,1,15,
     1,15,1,24,1,122,29,83,111,117,114,99,101,108,101,115,
     115,70,105,108,101,76,111,97,100,101,114,46,103,101,116,95,
     99,111,100,101,99,2,0,0,0,0,0,0,0,2,0,0,
@@ -1495,13 +1495,13 @@ const unsigned char _Py_M__importlib_external[] = {
     32,115,111,117,114,99,101,32,99,111,100,101,46,78,114,4,
     0,0,0,41,2,114,108,0,0,0,114,126,0,0,0,114,
     4,0,0,0,114,4,0,0,0,114,5,0,0,0,114,202,
-    0,0,0,107,3,0,0,115,2,0,0,0,0,2,122,31,
+    0,0,0,108,3,0,0,115,2,0,0,0,0,2,122,31,
     83,111,117,114,99,101,108,101,115,115,70,105,108,101,76,111,
     97,100,101,114,46,103,101,116,95,115,111,117,114,99,101,78,
     41,6,114,112,0,0,0,114,111,0,0,0,114,113,0,0,
     0,114,114,0,0,0,114,187,0,0,0,114,202,0,0,0,
     114,4,0,0,0,114,4,0,0,0,114,4,0,0,0,114,
-    5,0,0,0,114,223,0,0,0,97,3,0,0,115,6,0,
+    5,0,0,0,114,223,0,0,0,98,3,0,0,115,6,0,
     0,0,12,2,6,2,12,6,114,223,0,0,0,99,0,0,
     0,0,0,0,0,0,0,0,0,0,3,0,0,0,64,0,
     0,0,115,136,0,0,0,101,0,0,90,1,0,100,0,0,
@@ -1526,7 +1526,7 @@ const unsigned char _Py_M__importlib_external[] = {
     0,100,0,0,83,41,1,78,41,2,114,106,0,0,0,114,
     35,0,0,0,41,3,114,108,0,0,0,114,106,0,0,0,
     114,35,0,0,0,114,4,0,0,0,114,4,0,0,0,114,
-    5,0,0,0,114,185,0,0,0,124,3,0,0,115,4,0,
+    5,0,0,0,114,185,0,0,0,125,3,0,0,115,4,0,
     0,0,0,1,9,1,122,28,69,120,116,101,110,115,105,111,
     110,70,105,108,101,76,111,97,100,101,114,46,95,95,105,110,
     105,116,95,95,99,2,0,0,0,0,0,0,0,2,0,0,
@@ -1535,7 +1535,7 @@ const unsigned char _Py_M__importlib_external[] = {
     124,0,0,106,1,0,124,1,0,106,1,0,107,2,0,83,
     41,1,78,41,2,114,211,0,0,0,114,118,0,0,0,41,
     2,114,108,0,0,0,114,212,0,0,0,114,4,0,0,0,
-    114,4,0,0,0,114,5,0,0,0,114,213,0,0,0,128,
+    114,4,0,0,0,114,5,0,0,0,114,213,0,0,0,129,
     3,0,0,115,4,0,0,0,0,1,18,1,122,26,69,120,
     116,101,110,115,105,111,110,70,105,108,101,76,111,97,100,101,
     114,46,95,95,101,113,95,95,99,1,0,0,0,0,0,0,
@@ -1544,7 +1544,7 @@ const unsigned char _Py_M__importlib_external[] = {
     0,124,0,0,106,2,0,131,1,0,65,83,41,1,78,41,
     3,114,214,0,0,0,114,106,0,0,0,114,35,0,0,0,
     41,1,114,108,0,0,0,114,4,0,0,0,114,4,0,0,
-    0,114,5,0,0,0,114,215,0,0,0,132,3,0,0,115,
+    0,114,5,0,0,0,114,215,0,0,0,133,3,0,0,115,
     2,0,0,0,0,1,122,28,69,120,116,101,110,115,105,111,
     110,70,105,108,101,76,111,97,100,101,114,46,95,95,104,97,
     115,104,95,95,99,2,0,0,0,0,0,0,0,3,0,0,
@@ -1562,7 +1562,7 @@ const unsigned char _Py_M__importlib_external[] = {
     114,105,0,0,0,114,106,0,0,0,114,35,0,0,0,41,
     3,114,108,0,0,0,114,164,0,0,0,114,190,0,0,0,
     114,4,0,0,0,114,4,0,0,0,114,5,0,0,0,114,
-    186,0,0,0,135,3,0,0,115,10,0,0,0,0,2,6,
+    186,0,0,0,136,3,0,0,115,10,0,0,0,0,2,6,
     1,15,1,6,1,16,1,122,33,69,120,116,101,110,115,105,
     111,110,70,105,108,101,76,111,97,100,101,114,46,99,114,101,
     97,116,101,95,109,111,100,117,108,101,99,2,0,0,0,0,
@@ -1579,7 +1579,7 @@ const unsigned char _Py_M__importlib_external[] = {
     12,101,120,101,99,95,100,121,110,97,109,105,99,114,105,0,
     0,0,114,106,0,0,0,114,35,0,0,0,41,2,114,108,
     0,0,0,114,190,0,0,0,114,4,0,0,0,114,4,0,
-    0,0,114,5,0,0,0,114,191,0,0,0,143,3,0,0,
+    0,0,114,5,0,0,0,114,191,0,0,0,144,3,0,0,
     115,6,0,0,0,0,2,19,1,6,1,122,31,69,120,116,
     101,110,115,105,111,110,70,105,108,101,76,111,97,100,101,114,
     46,101,120,101,99,95,109,111,100,117,108,101,99,2,0,0,
@@ -1598,7 +1598,7 @@ const unsigned char _Py_M__importlib_external[] = {
     78,114,4,0,0,0,41,2,114,22,0,0,0,218,6,115,
     117,102,102,105,120,41,1,218,9,102,105,108,101,95,110,97,
     109,101,114,4,0,0,0,114,5,0,0,0,250,9,60,103,
-    101,110,101,120,112,114,62,152,3,0,0,115,2,0,0,0,
+    101,110,101,120,112,114,62,153,3,0,0,115,2,0,0,0,
     6,1,122,49,69,120,116,101,110,115,105,111,110,70,105,108,
     101,76,111,97,100,101,114,46,105,115,95,112,97,99,107,97,
     103,101,46,60,108,111,99,97,108,115,62,46,60,103,101,110,
@@ -1606,7 +1606,7 @@ const unsigned char _Py_M__importlib_external[] = {
     0,218,3,97,110,121,218,18,69,88,84,69,78,83,73,79,
     78,95,83,85,70,70,73,88,69,83,41,2,114,108,0,0,
     0,114,126,0,0,0,114,4,0,0,0,41,1,114,226,0,
-    0,0,114,5,0,0,0,114,159,0,0,0,149,3,0,0,
+    0,0,114,5,0,0,0,114,159,0,0,0,150,3,0,0,
     115,6,0,0,0,0,2,19,1,18,1,122,30,69,120,116,
     101,110,115,105,111,110,70,105,108,101,76,111,97,100,101,114,
     46,105,115,95,112,97,99,107,97,103,101,99,2,0,0,0,
@@ -1618,7 +1618,7 @@ const unsigned char _Py_M__importlib_external[] = {
     99,111,100,101,32,111,98,106,101,99,116,46,78,114,4,0,
     0,0,41,2,114,108,0,0,0,114,126,0,0,0,114,4,
     0,0,0,114,4,0,0,0,114,5,0,0,0,114,187,0,
-    0,0,155,3,0,0,115,2,0,0,0,0,2,122,28,69,
+    0,0,156,3,0,0,115,2,0,0,0,0,2,122,28,69,
     120,116,101,110,115,105,111,110,70,105,108,101,76,111,97,100,
     101,114,46,103,101,116,95,99,111,100,101,99,2,0,0,0,
     0,0,0,0,2,0,0,0,1,0,0,0,67,0,0,0,
@@ -1628,7 +1628,7 @@ const unsigned char _Py_M__importlib_external[] = {
     118,101,32,110,111,32,115,111,117,114,99,101,32,99,111,100,
     101,46,78,114,4,0,0,0,41,2,114,108,0,0,0,114,
     126,0,0,0,114,4,0,0,0,114,4,0,0,0,114,5,
-    0,0,0,114,202,0,0,0,159,3,0,0,115,2,0,0,
+    0,0,0,114,202,0,0,0,160,3,0,0,115,2,0,0,
     0,0,2,122,30,69,120,116,101,110,115,105,111,110,70,105,
     108,101,76,111,97,100,101,114,46,103,101,116,95,115,111,117,
     114,99,101,99,2,0,0,0,0,0,0,0,2,0,0,0,
@@ -1639,7 +1639,7 @@ const unsigned char _Py_M__importlib_external[] = {
     117,110,100,32,98,121,32,116,104,101,32,102,105,110,100,101,
     114,46,41,1,114,35,0,0,0,41,2,114,108,0,0,0,
     114,126,0,0,0,114,4,0,0,0,114,4,0,0,0,114,
-    5,0,0,0,114,157,0,0,0,163,3,0,0,115,2,0,
+    5,0,0,0,114,157,0,0,0,164,3,0,0,115,2,0,
     0,0,0,3,122,32,69,120,116,101,110,115,105,111,110,70,
     105,108,101,76,111,97,100,101,114,46,103,101,116,95,102,105,
     108,101,110,97,109,101,78,41,14,114,112,0,0,0,114,111,
@@ -1648,7 +1648,7 @@ const unsigned char _Py_M__importlib_external[] = {
     0,114,191,0,0,0,114,159,0,0,0,114,187,0,0,0,
     114,202,0,0,0,114,123,0,0,0,114,157,0,0,0,114,
     4,0,0,0,114,4,0,0,0,114,4,0,0,0,114,5,
-    0,0,0,114,224,0,0,0,116,3,0,0,115,20,0,0,
+    0,0,0,114,224,0,0,0,117,3,0,0,115,20,0,0,
     0,12,6,6,2,12,4,12,4,12,3,12,8,12,6,12,
     6,12,4,12,4,114,224,0,0,0,99,0,0,0,0,0,
     0,0,0,0,0,0,0,2,0,0,0,64,0,0,0,115,
@@ -1692,7 +1692,7 @@ const unsigned char _Py_M__importlib_external[] = {
     95,112,97,116,104,95,102,105,110,100,101,114,41,4,114,108,
     0,0,0,114,106,0,0,0,114,35,0,0,0,218,11,112,
     97,116,104,95,102,105,110,100,101,114,114,4,0,0,0,114,
-    4,0,0,0,114,5,0,0,0,114,185,0,0,0,176,3,
+    4,0,0,0,114,5,0,0,0,114,185,0,0,0,177,3,
     0,0,115,8,0,0,0,0,1,9,1,9,1,21,1,122,
     23,95,78,97,109,101,115,112,97,99,101,80,97,116,104,46,
     95,95,105,110,105,116,95,95,99,1,0,0,0,0,0,0,
@@ -1711,7 +1711,7 @@ const unsigned char _Py_M__importlib_external[] = {
     41,4,114,108,0,0,0,114,222,0,0,0,218,3,100,111,
     116,90,2,109,101,114,4,0,0,0,114,4,0,0,0,114,
     5,0,0,0,218,23,95,102,105,110,100,95,112,97,114,101,
-    110,116,95,112,97,116,104,95,110,97,109,101,115,182,3,0,
+    110,116,95,112,97,116,104,95,110,97,109,101,115,183,3,0,
     0,115,8,0,0,0,0,2,27,1,12,2,4,3,122,38,
     95,78,97,109,101,115,112,97,99,101,80,97,116,104,46,95,
     102,105,110,100,95,112,97,114,101,110,116,95,112,97,116,104,
@@ -1725,7 +1725,7 @@ const unsigned char _Py_M__importlib_external[] = {
     110,116,95,109,111,100,117,108,101,95,110,97,109,101,90,14,
     112,97,116,104,95,97,116,116,114,95,110,97,109,101,114,4,
     0,0,0,114,4,0,0,0,114,5,0,0,0,114,233,0,
-    0,0,192,3,0,0,115,4,0,0,0,0,1,18,1,122,
+    0,0,193,3,0,0,115,4,0,0,0,0,1,18,1,122,
     31,95,78,97,109,101,115,112,97,99,101,80,97,116,104,46,
     95,103,101,116,95,112,97,114,101,110,116,95,112,97,116,104,
     99,1,0,0,0,0,0,0,0,3,0,0,0,3,0,0,
@@ -1743,7 +1743,7 @@ const unsigned char _Py_M__importlib_external[] = {
     108,0,0,0,90,11,112,97,114,101,110,116,95,112,97,116,
     104,114,164,0,0,0,114,4,0,0,0,114,4,0,0,0,
     114,5,0,0,0,218,12,95,114,101,99,97,108,99,117,108,
-    97,116,101,196,3,0,0,115,16,0,0,0,0,2,18,1,
+    97,116,101,197,3,0,0,115,16,0,0,0,0,2,18,1,
     15,1,21,3,27,1,9,1,12,1,9,1,122,27,95,78,
     97,109,101,115,112,97,99,101,80,97,116,104,46,95,114,101,
     99,97,108,99,117,108,97,116,101,99,1,0,0,0,0,0,
@@ -1752,14 +1752,14 @@ const unsigned char _Py_M__importlib_external[] = {
     1,0,83,41,1,78,41,2,218,4,105,116,101,114,114,240,
     0,0,0,41,1,114,108,0,0,0,114,4,0,0,0,114,
     4,0,0,0,114,5,0,0,0,218,8,95,95,105,116,101,
-    114,95,95,209,3,0,0,115,2,0,0,0,0,1,122,23,
+    114,95,95,210,3,0,0,115,2,0,0,0,0,1,122,23,
     95,78,97,109,101,115,112,97,99,101,80,97,116,104,46,95,
     95,105,116,101,114,95,95,99,1,0,0,0,0,0,0,0,
     1,0,0,0,2,0,0,0,67,0,0,0,115,16,0,0,
     0,116,0,0,124,0,0,106,1,0,131,0,0,131,1,0,
     83,41,1,78,41,2,114,31,0,0,0,114,240,0,0,0,
     41,1,114,108,0,0,0,114,4,0,0,0,114,4,0,0,
-    0,114,5,0,0,0,218,7,95,95,108,101,110,95,95,212,
+    0,114,5,0,0,0,218,7,95,95,108,101,110,95,95,213,
     3,0,0,115,2,0,0,0,0,1,122,22,95,78,97,109,
     101,115,112,97,99,101,80,97,116,104,46,95,95,108,101,110,
     95,95,99,1,0,0,0,0,0,0,0,1,0,0,0,2,
@@ -1769,7 +1769,7 @@ const unsigned char _Py_M__importlib_external[] = {
     123,33,114,125,41,41,2,114,47,0,0,0,114,232,0,0,
     0,41,1,114,108,0,0,0,114,4,0,0,0,114,4,0,
     0,0,114,5,0,0,0,218,8,95,95,114,101,112,114,95,
-    95,215,3,0,0,115,2,0,0,0,0,1,122,23,95,78,
+    95,216,3,0,0,115,2,0,0,0,0,1,122,23,95,78,
     97,109,101,115,112,97,99,101,80,97,116,104,46,95,95,114,
     101,112,114,95,95,99,2,0,0,0,0,0,0,0,2,0,
     0,0,2,0,0,0,67,0,0,0,115,16,0,0,0,124,
@@ -1777,7 +1777,7 @@ const unsigned char _Py_M__importlib_external[] = {
     1,78,41,1,114,240,0,0,0,41,2,114,108,0,0,0,
     218,4,105,116,101,109,114,4,0,0,0,114,4,0,0,0,
     114,5,0,0,0,218,12,95,95,99,111,110,116,97,105,110,
-    115,95,95,218,3,0,0,115,2,0,0,0,0,1,122,27,
+    115,95,95,219,3,0,0,115,2,0,0,0,0,1,122,27,
     95,78,97,109,101,115,112,97,99,101,80,97,116,104,46,95,
     95,99,111,110,116,97,105,110,115,95,95,99,2,0,0,0,
     0,0,0,0,2,0,0,0,2,0,0,0,67,0,0,0,
@@ -1785,7 +1785,7 @@ const unsigned char _Py_M__importlib_external[] = {
     0,131,1,0,1,100,0,0,83,41,1,78,41,2,114,232,
     0,0,0,114,163,0,0,0,41,2,114,108,0,0,0,114,
     245,0,0,0,114,4,0,0,0,114,4,0,0,0,114,5,
-    0,0,0,114,163,0,0,0,221,3,0,0,115,2,0,0,
+    0,0,0,114,163,0,0,0,222,3,0,0,115,2,0,0,
     0,0,1,122,21,95,78,97,109,101,115,112,97,99,101,80,
     97,116,104,46,97,112,112,101,110,100,78,41,13,114,112,0,
     0,0,114,111,0,0,0,114,113,0,0,0,114,114,0,0,
@@ -1793,7 +1793,7 @@ const unsigned char _Py_M__importlib_external[] = {
     114,240,0,0,0,114,242,0,0,0,114,243,0,0,0,114,
     244,0,0,0,114,246,0,0,0,114,163,0,0,0,114,4,
     0,0,0,114,4,0,0,0,114,4,0,0,0,114,5,0,
-    0,0,114,230,0,0,0,169,3,0,0,115,20,0,0,0,
+    0,0,114,230,0,0,0,170,3,0,0,115,20,0,0,0,
     12,5,6,2,12,6,12,10,12,4,12,13,12,3,12,3,
     12,3,12,3,114,230,0,0,0,99,0,0,0,0,0,0,
     0,0,0,0,0,0,3,0,0,0,64,0,0,0,115,118,
@@ -1812,7 +1812,7 @@ const unsigned char _Py_M__importlib_external[] = {
     41,1,78,41,2,114,230,0,0,0,114,232,0,0,0,41,
     4,114,108,0,0,0,114,106,0,0,0,114,35,0,0,0,
     114,236,0,0,0,114,4,0,0,0,114,4,0,0,0,114,
-    5,0,0,0,114,185,0,0,0,227,3,0,0,115,2,0,
+    5,0,0,0,114,185,0,0,0,228,3,0,0,115,2,0,
     0,0,0,1,122,25,95,78,97,109,101,115,112,97,99,101,
     76,111,97,100,101,114,46,95,95,105,110,105,116,95,95,99,
     2,0,0,0,0,0,0,0,2,0,0,0,2,0,0,0,
@@ -1829,14 +1829,14 @@ const unsigned char _Py_M__importlib_external[] = {
     110,97,109,101,115,112,97,99,101,41,62,41,2,114,47,0,
     0,0,114,112,0,0,0,41,2,114,170,0,0,0,114,190,
     0,0,0,114,4,0,0,0,114,4,0,0,0,114,5,0,
-    0,0,218,11,109,111,100,117,108,101,95,114,101,112,114,230,
+    0,0,218,11,109,111,100,117,108,101,95,114,101,112,114,231,
     3,0,0,115,2,0,0,0,0,7,122,28,95,78,97,109,
     101,115,112,97,99,101,76,111,97,100,101,114,46,109,111,100,
     117,108,101,95,114,101,112,114,99,2,0,0,0,0,0,0,
     0,2,0,0,0,1,0,0,0,67,0,0,0,115,4,0,
     0,0,100,1,0,83,41,2,78,84,114,4,0,0,0,41,
     2,114,108,0,0,0,114,126,0,0,0,114,4,0,0,0,
-    114,4,0,0,0,114,5,0,0,0,114,159,0,0,0,239,
+    114,4,0,0,0,114,5,0,0,0,114,159,0,0,0,240,
     3,0,0,115,2,0,0,0,0,1,122,27,95,78,97,109,
     101,115,112,97,99,101,76,111,97,100,101,114,46,105,115,95,
     112,97,99,107,97,103,101,99,2,0,0,0,0,0,0,0,
@@ -1844,7 +1844,7 @@ const unsigned char _Py_M__importlib_external[] = {
     0,100,1,0,83,41,2,78,114,30,0,0,0,114,4,0,
     0,0,41,2,114,108,0,0,0,114,126,0,0,0,114,4,
     0,0,0,114,4,0,0,0,114,5,0,0,0,114,202,0,
-    0,0,242,3,0,0,115,2,0,0,0,0,1,122,27,95,
+    0,0,243,3,0,0,115,2,0,0,0,0,1,122,27,95,
     78,97,109,101,115,112,97,99,101,76,111,97,100,101,114,46,
     103,101,116,95,115,111,117,114,99,101,99,2,0,0,0,0,
     0,0,0,2,0,0,0,6,0,0,0,67,0,0,0,115,
@@ -1853,7 +1853,7 @@ const unsigned char _Py_M__importlib_external[] = {
     0,0,122,8,60,115,116,114,105,110,103,62,114,189,0,0,
     0,114,204,0,0,0,84,41,1,114,205,0,0,0,41,2,
     114,108,0,0,0,114,126,0,0,0,114,4,0,0,0,114,
-    4,0,0,0,114,5,0,0,0,114,187,0,0,0,245,3,
+    4,0,0,0,114,5,0,0,0,114,187,0,0,0,246,3,
     0,0,115,2,0,0,0,0,1,122,25,95,78,97,109,101,
     115,112,97,99,101,76,111,97,100,101,114,46,103,101,116,95,
     99,111,100,101,99,2,0,0,0,0,0,0,0,2,0,0,
@@ -1863,14 +1863,14 @@ const unsigned char _Py_M__importlib_external[] = {
     109,111,100,117,108,101,32,99,114,101,97,116,105,111,110,46,
     78,114,4,0,0,0,41,2,114,108,0,0,0,114,164,0,
     0,0,114,4,0,0,0,114,4,0,0,0,114,5,0,0,
-    0,114,186,0,0,0,248,3,0,0,115,0,0,0,0,122,
+    0,114,186,0,0,0,249,3,0,0,115,0,0,0,0,122,
     30,95,78,97,109,101,115,112,97,99,101,76,111,97,100,101,
     114,46,99,114,101,97,116,101,95,109,111,100,117,108,101,99,
     2,0,0,0,0,0,0,0,2,0,0,0,1,0,0,0,
     67,0,0,0,115,4,0,0,0,100,0,0,83,41,1,78,
     114,4,0,0,0,41,2,114,108,0,0,0,114,190,0,0,
     0,114,4,0,0,0,114,4,0,0,0,114,5,0,0,0,
-    114,191,0,0,0,251,3,0,0,115,2,0,0,0,0,1,
+    114,191,0,0,0,252,3,0,0,115,2,0,0,0,0,1,
     122,28,95,78,97,109,101,115,112,97,99,101,76,111,97,100,
     101,114,46,101,120,101,99,95,109,111,100,117,108,101,99,2,
     0,0,0,0,0,0,0,2,0,0,0,3,0,0,0,67,
@@ -1888,7 +1888,7 @@ const unsigned char _Py_M__importlib_external[] = {
     104,32,123,33,114,125,41,4,114,105,0,0,0,114,232,0,
     0,0,114,121,0,0,0,114,192,0,0,0,41,2,114,108,
     0,0,0,114,126,0,0,0,114,4,0,0,0,114,4,0,
-    0,0,114,5,0,0,0,114,193,0,0,0,254,3,0,0,
+    0,0,114,5,0,0,0,114,193,0,0,0,255,3,0,0,
     115,4,0,0,0,0,7,16,1,122,28,95,78,97,109,101,
     115,112,97,99,101,76,111,97,100,101,114,46,108,111,97,100,
     95,109,111,100,117,108,101,78,41,12,114,112,0,0,0,114,
@@ -1896,7 +1896,7 @@ const unsigned char _Py_M__importlib_external[] = {
     0,0,0,114,248,0,0,0,114,159,0,0,0,114,202,0,
     0,0,114,187,0,0,0,114,186,0,0,0,114,191,0,0,
     0,114,193,0,0,0,114,4,0,0,0,114,4,0,0,0,
-    114,4,0,0,0,114,5,0,0,0,114,247,0,0,0,226,
+    114,4,0,0,0,114,5,0,0,0,114,247,0,0,0,227,
     3,0,0,115,16,0,0,0,12,1,12,3,18,9,12,3,
     12,3,12,3,12,3,12,3,114,247,0,0,0,99,0,0,
     0,0,0,0,0,0,0,0,0,0,5,0,0,0,64,0,
@@ -1934,7 +1934,7 @@ const unsigned char _Py_M__importlib_external[] = {
     114,95,99,97,99,104,101,218,6,118,97,108,117,101,115,114,
     115,0,0,0,114,250,0,0,0,41,2,114,170,0,0,0,
     218,6,102,105,110,100,101,114,114,4,0,0,0,114,4,0,
-    0,0,114,5,0,0,0,114,250,0,0,0,15,4,0,0,
+    0,0,114,5,0,0,0,114,250,0,0,0,16,4,0,0,
     115,6,0,0,0,0,4,22,1,15,1,122,28,80,97,116,
     104,70,105,110,100,101,114,46,105,110,118,97,108,105,100,97,
     116,101,95,99,97,99,104,101,115,99,2,0,0,0,0,0,
@@ -1960,7 +1960,7 @@ const unsigned char _Py_M__importlib_external[] = {
     107,0,0,0,41,3,114,170,0,0,0,114,35,0,0,0,
     90,4,104,111,111,107,114,4,0,0,0,114,4,0,0,0,
     114,5,0,0,0,218,11,95,112,97,116,104,95,104,111,111,
-    107,115,23,4,0,0,115,16,0,0,0,0,7,25,1,16,
+    107,115,24,4,0,0,115,16,0,0,0,0,7,25,1,16,
     1,16,1,3,1,14,1,13,1,12,2,122,22,80,97,116,
     104,70,105,110,100,101,114,46,95,112,97,116,104,95,104,111,
     111,107,115,99,2,0,0,0,0,0,0,0,3,0,0,0,
@@ -1992,7 +1992,7 @@ const unsigned char _Py_M__importlib_external[] = {
     0,0,114,255,0,0,0,41,3,114,170,0,0,0,114,35,
     0,0,0,114,253,0,0,0,114,4,0,0,0,114,4,0,
     0,0,114,5,0,0,0,218,20,95,112,97,116,104,95,105,
-    109,112,111,114,116,101,114,95,99,97,99,104,101,40,4,0,
+    109,112,111,114,116,101,114,95,99,97,99,104,101,41,4,0,
     0,115,22,0,0,0,0,8,12,1,3,1,16,1,13,3,
     9,1,3,1,17,1,13,1,15,1,18,1,122,31,80,97,
     116,104,70,105,110,100,101,114,46,95,112,97,116,104,95,105,
@@ -2012,7 +2012,7 @@ const unsigned char _Py_M__importlib_external[] = {
     0,0,114,126,0,0,0,114,253,0,0,0,114,127,0,0,
     0,114,128,0,0,0,114,164,0,0,0,114,4,0,0,0,
     114,4,0,0,0,114,5,0,0,0,218,16,95,108,101,103,
-    97,99,121,95,103,101,116,95,115,112,101,99,62,4,0,0,
+    97,99,121,95,103,101,116,95,115,112,101,99,63,4,0,0,
     115,18,0,0,0,0,4,15,1,24,2,15,1,6,1,12,
     1,16,1,18,1,9,1,122,27,80,97,116,104,70,105,110,
     100,101,114,46,95,108,101,103,97,99,121,95,103,101,116,95,
@@ -2048,7 +2048,7 @@ const unsigned char _Py_M__importlib_external[] = {
     101,115,112,97,99,101,95,112,97,116,104,90,5,101,110,116,
     114,121,114,253,0,0,0,114,164,0,0,0,114,128,0,0,
     0,114,4,0,0,0,114,4,0,0,0,114,5,0,0,0,
-    218,9,95,103,101,116,95,115,112,101,99,77,4,0,0,115,
+    218,9,95,103,101,116,95,115,112,101,99,78,4,0,0,115,
     40,0,0,0,0,5,6,1,13,1,21,1,3,1,15,1,
     12,1,15,1,21,2,18,1,12,1,3,1,15,1,4,1,
     9,1,12,1,12,5,17,2,18,1,9,1,122,20,80,97,
@@ -2076,7 +2076,7 @@ const unsigned char _Py_M__importlib_external[] = {
     6,114,170,0,0,0,114,126,0,0,0,114,35,0,0,0,
     114,180,0,0,0,114,164,0,0,0,114,4,1,0,0,114,
     4,0,0,0,114,4,0,0,0,114,5,0,0,0,114,181,
-    0,0,0,109,4,0,0,115,26,0,0,0,0,4,12,1,
+    0,0,0,110,4,0,0,115,26,0,0,0,0,4,12,1,
     9,1,21,1,12,1,4,1,15,1,9,1,6,3,9,1,
     24,1,4,2,7,2,122,20,80,97,116,104,70,105,110,100,
     101,114,46,102,105,110,100,95,115,112,101,99,99,3,0,0,
@@ -2098,7 +2098,7 @@ const unsigned char _Py_M__importlib_external[] = {
     114,181,0,0,0,114,127,0,0,0,41,4,114,170,0,0,
     0,114,126,0,0,0,114,35,0,0,0,114,164,0,0,0,
     114,4,0,0,0,114,4,0,0,0,114,5,0,0,0,114,
-    182,0,0,0,131,4,0,0,115,8,0,0,0,0,8,18,
+    182,0,0,0,132,4,0,0,115,8,0,0,0,0,8,18,
     1,12,1,4,1,122,22,80,97,116,104,70,105,110,100,101,
     114,46,102,105,110,100,95,109,111,100,117,108,101,41,12,114,
     112,0,0,0,114,111,0,0,0,114,113,0,0,0,114,114,
@@ -2106,7 +2106,7 @@ const unsigned char _Py_M__importlib_external[] = {
     0,0,114,1,1,0,0,114,2,1,0,0,114,5,1,0,
     0,114,181,0,0,0,114,182,0,0,0,114,4,0,0,0,
     114,4,0,0,0,114,4,0,0,0,114,5,0,0,0,114,
-    249,0,0,0,11,4,0,0,115,22,0,0,0,12,2,6,
+    249,0,0,0,12,4,0,0,115,22,0,0,0,12,2,6,
     2,18,8,18,17,18,22,18,15,3,1,18,31,3,1,21,
     21,3,1,114,249,0,0,0,99,0,0,0,0,0,0,0,
     0,0,0,0,0,3,0,0,0,64,0,0,0,115,133,0,
@@ -2155,7 +2155,7 @@ const unsigned char _Py_M__importlib_external[] = {
     0,86,1,113,3,0,100,0,0,83,41,1,78,114,4,0,
     0,0,41,2,114,22,0,0,0,114,225,0,0,0,41,1,
     114,127,0,0,0,114,4,0,0,0,114,5,0,0,0,114,
-    227,0,0,0,160,4,0,0,115,2,0,0,0,6,0,122,
+    227,0,0,0,161,4,0,0,115,2,0,0,0,6,0,122,
     38,70,105,108,101,70,105,110,100,101,114,46,95,95,105,110,
     105,116,95,95,46,60,108,111,99,97,108,115,62,46,60,103,
     101,110,101,120,112,114,62,114,58,0,0,0,114,29,0,0,
@@ -2168,7 +2168,7 @@ const unsigned char _Py_M__importlib_external[] = {
     111,97,100,101,114,95,100,101,116,97,105,108,115,90,7,108,
     111,97,100,101,114,115,114,166,0,0,0,114,4,0,0,0,
     41,1,114,127,0,0,0,114,5,0,0,0,114,185,0,0,
-    0,154,4,0,0,115,16,0,0,0,0,4,6,1,19,1,
+    0,155,4,0,0,115,16,0,0,0,0,4,6,1,19,1,
     36,1,9,2,15,1,9,1,12,1,122,19,70,105,108,101,
     70,105,110,100,101,114,46,95,95,105,110,105,116,95,95,99,
     1,0,0,0,0,0,0,0,1,0,0,0,2,0,0,0,
@@ -2178,7 +2178,7 @@ const unsigned char _Py_M__importlib_external[] = {
     114,121,32,109,116,105,109,101,46,114,29,0,0,0,78,114,
     87,0,0,0,41,1,114,8,1,0,0,41,1,114,108,0,
     0,0,114,4,0,0,0,114,4,0,0,0,114,5,0,0,
-    0,114,250,0,0,0,168,4,0,0,115,2,0,0,0,0,
+    0,114,250,0,0,0,169,4,0,0,115,2,0,0,0,0,
     2,122,28,70,105,108,101,70,105,110,100,101,114,46,105,110,
     118,97,108,105,100,97,116,101,95,99,97,99,104,101,115,99,
     2,0,0,0,0,0,0,0,3,0,0,0,2,0,0,0,
@@ -2202,7 +2202,7 @@ const unsigned char _Py_M__importlib_external[] = {
     114,181,0,0,0,114,127,0,0,0,114,156,0,0,0,41,
     3,114,108,0,0,0,114,126,0,0,0,114,164,0,0,0,
     114,4,0,0,0,114,4,0,0,0,114,5,0,0,0,114,
-    124,0,0,0,174,4,0,0,115,8,0,0,0,0,7,15,
+    124,0,0,0,175,4,0,0,115,8,0,0,0,0,7,15,
     1,12,1,10,1,122,22,70,105,108,101,70,105,110,100,101,
     114,46,102,105,110,100,95,108,111,97,100,101,114,99,6,0,
     0,0,0,0,0,0,7,0,0,0,7,0,0,0,67,0,
@@ -2213,7 +2213,7 @@ const unsigned char _Py_M__importlib_external[] = {
     0,0,0,41,7,114,108,0,0,0,114,165,0,0,0,114,
     126,0,0,0,114,35,0,0,0,90,4,115,109,115,108,114,
     180,0,0,0,114,127,0,0,0,114,4,0,0,0,114,4,
-    0,0,0,114,5,0,0,0,114,5,1,0,0,186,4,0,
+    0,0,0,114,5,0,0,0,114,5,1,0,0,187,4,0,
     0,115,6,0,0,0,0,1,15,1,18,1,122,20,70,105,
     108,101,70,105,110,100,101,114,46,95,103,101,116,95,115,112,
     101,99,78,99,3,0,0,0,0,0,0,0,14,0,0,0,
@@ -2276,7 +2276,7 @@ const unsigned char _Py_M__importlib_external[] = {
     13,105,110,105,116,95,102,105,108,101,110,97,109,101,90,9,
     102,117,108,108,95,112,97,116,104,114,164,0,0,0,114,4,
     0,0,0,114,4,0,0,0,114,5,0,0,0,114,181,0,
-    0,0,191,4,0,0,115,68,0,0,0,0,3,6,1,19,
+    0,0,192,4,0,0,115,68,0,0,0,0,3,6,1,19,
     1,3,1,34,1,13,1,11,1,15,1,10,1,9,2,9,
     1,9,1,15,2,9,1,6,2,12,1,18,1,22,1,10,
     1,15,1,12,1,32,4,12,2,22,1,22,1,25,1,16,
@@ -2312,7 +2312,7 @@ const unsigned char _Py_M__importlib_external[] = {
     0,0,146,2,0,113,6,0,83,114,4,0,0,0,41,1,
     114,88,0,0,0,41,2,114,22,0,0,0,90,2,102,110,
     114,4,0,0,0,114,4,0,0,0,114,5,0,0,0,250,
-    9,60,115,101,116,99,111,109,112,62,9,5,0,0,115,2,
+    9,60,115,101,116,99,111,109,112,62,10,5,0,0,115,2,
     0,0,0,9,0,122,41,70,105,108,101,70,105,110,100,101,
     114,46,95,102,105,108,108,95,99,97,99,104,101,46,60,108,
     111,99,97,108,115,62,46,60,115,101,116,99,111,109,112,62,
@@ -2329,7 +2329,7 @@ const unsigned char _Py_M__importlib_external[] = {
     95,99,111,110,116,101,110,116,115,114,245,0,0,0,114,106,
     0,0,0,114,237,0,0,0,114,225,0,0,0,90,8,110,
     101,119,95,110,97,109,101,114,4,0,0,0,114,4,0,0,
-    0,114,5,0,0,0,114,13,1,0,0,236,4,0,0,115,
+    0,114,5,0,0,0,114,13,1,0,0,237,4,0,0,115,
     34,0,0,0,0,2,9,1,3,1,31,1,22,3,11,3,
     18,1,18,7,9,1,13,1,24,1,6,1,27,2,6,1,
     17,1,9,1,18,1,122,22,70,105,108,101,70,105,110,100,
@@ -2368,7 +2368,7 @@ const unsigned char _Py_M__importlib_external[] = {
     0,0,0,41,1,114,35,0,0,0,41,2,114,170,0,0,
     0,114,12,1,0,0,114,4,0,0,0,114,5,0,0,0,
     218,24,112,97,116,104,95,104,111,111,107,95,102,111,114,95,
-    70,105,108,101,70,105,110,100,101,114,21,5,0,0,115,6,
+    70,105,108,101,70,105,110,100,101,114,22,5,0,0,115,6,
     0,0,0,0,2,12,1,18,1,122,54,70,105,108,101,70,
     105,110,100,101,114,46,112,97,116,104,95,104,111,111,107,46,
     60,108,111,99,97,108,115,62,46,112,97,116,104,95,104,111,
@@ -2376,7 +2376,7 @@ const unsigned char _Py_M__importlib_external[] = {
     114,114,4,0,0,0,41,3,114,170,0,0,0,114,12,1,
     0,0,114,18,1,0,0,114,4,0,0,0,41,2,114,170,
     0,0,0,114,12,1,0,0,114,5,0,0,0,218,9,112,
-    97,116,104,95,104,111,111,107,11,5,0,0,115,4,0,0,
+    97,116,104,95,104,111,111,107,12,5,0,0,115,4,0,0,
     0,0,10,21,6,122,20,70,105,108,101,70,105,110,100,101,
     114,46,112,97,116,104,95,104,111,111,107,99,1,0,0,0,
     0,0,0,0,1,0,0,0,2,0,0,0,67,0,0,0,
@@ -2385,7 +2385,7 @@ const unsigned char _Py_M__importlib_external[] = {
     110,100,101,114,40,123,33,114,125,41,41,2,114,47,0,0,
     0,114,35,0,0,0,41,1,114,108,0,0,0,114,4,0,
     0,0,114,4,0,0,0,114,5,0,0,0,114,244,0,0,
-    0,29,5,0,0,115,2,0,0,0,0,1,122,19,70,105,
+    0,30,5,0,0,115,2,0,0,0,0,1,122,19,70,105,
     108,101,70,105,110,100,101,114,46,95,95,114,101,112,114,95,
     95,41,15,114,112,0,0,0,114,111,0,0,0,114,113,0,
     0,0,114,114,0,0,0,114,185,0,0,0,114,250,0,0,
@@ -2393,7 +2393,7 @@ const unsigned char _Py_M__importlib_external[] = {
     114,5,1,0,0,114,181,0,0,0,114,13,1,0,0,114,
     183,0,0,0,114,19,1,0,0,114,244,0,0,0,114,4,
     0,0,0,114,4,0,0,0,114,4,0,0,0,114,5,0,
-    0,0,114,6,1,0,0,145,4,0,0,115,20,0,0,0,
+    0,0,114,6,1,0,0,146,4,0,0,115,20,0,0,0,
     12,7,6,2,12,14,12,4,6,2,12,12,12,5,15,45,
     12,31,18,18,114,6,1,0,0,99,4,0,0,0,0,0,
     0,0,6,0,0,0,11,0,0,0,67,0,0,0,115,195,
@@ -2419,7 +2419,7 @@ const unsigned char _Py_M__importlib_external[] = {
     104,110,97,109,101,90,9,99,112,97,116,104,110,97,109,101,
     114,127,0,0,0,114,164,0,0,0,114,4,0,0,0,114,
     4,0,0,0,114,5,0,0,0,218,14,95,102,105,120,95,
-    117,112,95,109,111,100,117,108,101,35,5,0,0,115,34,0,
+    117,112,95,109,111,100,117,108,101,36,5,0,0,115,34,0,
     0,0,0,2,15,1,15,1,6,1,6,1,12,1,12,1,
     18,2,15,1,6,1,21,1,3,1,10,1,10,1,10,1,
     14,1,13,2,114,24,1,0,0,99,0,0,0,0,0,0,
@@ -2440,7 +2440,7 @@ const unsigned char _Py_M__importlib_external[] = {
     0,41,3,90,10,101,120,116,101,110,115,105,111,110,115,90,
     6,115,111,117,114,99,101,90,8,98,121,116,101,99,111,100,
     101,114,4,0,0,0,114,4,0,0,0,114,5,0,0,0,
-    114,161,0,0,0,58,5,0,0,115,8,0,0,0,0,5,
+    114,161,0,0,0,59,5,0,0,115,8,0,0,0,0,5,
     18,1,12,1,12,1,114,161,0,0,0,99,1,0,0,0,
     0,0,0,0,12,0,0,0,12,0,0,0,67,0,0,0,
     115,70,2,0,0,124,0,0,97,0,0,116,0,0,106,1,
@@ -2502,7 +2502,7 @@ const unsigned char _Py_M__importlib_external[] = {
     83,41,2,114,29,0,0,0,78,41,1,114,31,0,0,0,
     41,2,114,22,0,0,0,114,77,0,0,0,114,4,0,0,
     0,114,4,0,0,0,114,5,0,0,0,114,227,0,0,0,
-    94,5,0,0,115,2,0,0,0,6,0,122,25,95,115,101,
+    95,5,0,0,115,2,0,0,0,6,0,122,25,95,115,101,
     116,117,112,46,60,108,111,99,97,108,115,62,46,60,103,101,
     110,101,120,112,114,62,114,59,0,0,0,122,30,105,109,112,
     111,114,116,108,105,98,32,114,101,113,117,105,114,101,115,32,
@@ -2532,7 +2532,7 @@ const unsigned char _Py_M__importlib_external[] = {
     90,14,119,101,97,107,114,101,102,95,109,111,100,117,108,101,
     90,13,119,105,110,114,101,103,95,109,111,100,117,108,101,114,
     4,0,0,0,114,4,0,0,0,114,5,0,0,0,218,6,
-    95,115,101,116,117,112,69,5,0,0,115,82,0,0,0,0,
+    95,115,101,116,117,112,70,5,0,0,115,82,0,0,0,0,
     8,6,1,9,1,9,3,13,1,13,1,15,1,18,2,13,
     1,20,3,33,1,19,2,31,1,10,1,15,1,13,1,4,
     2,3,1,15,1,5,1,13,1,12,2,12,1,16,1,16,
@@ -2558,7 +2558,7 @@ const unsigned char _Py_M__importlib_external[] = {
     114,218,0,0,0,41,2,114,32,1,0,0,90,17,115,117,
     112,112,111,114,116,101,100,95,108,111,97,100,101,114,115,114,
     4,0,0,0,114,4,0,0,0,114,5,0,0,0,218,8,
-    95,105,110,115,116,97,108,108,137,5,0,0,115,16,0,0,
+    95,105,110,115,116,97,108,108,138,5,0,0,115,16,0,0,
     0,0,2,10,1,9,1,28,1,15,1,16,1,16,4,9,
     1,114,35,1,0,0,41,3,122,3,119,105,110,114,1,0,
     0,0,114,2,0,0,0,41,57,114,114,0,0,0,114,10,
@@ -2587,7 +2587,7 @@ const unsigned char _Py_M__importlib_external[] = {
     0,0,0,114,4,0,0,0,114,5,0,0,0,218,8,60,
     109,111,100,117,108,101,62,8,0,0,0,115,100,0,0,0,
     6,17,6,3,12,12,12,5,12,5,12,6,12,12,12,10,
-    12,9,12,5,12,7,15,22,15,113,22,1,18,2,6,1,
+    12,9,12,5,12,7,15,22,15,114,22,1,18,2,6,1,
     6,2,9,2,9,2,10,2,21,44,12,33,12,19,12,12,
     12,12,18,8,12,28,12,17,21,55,21,12,18,10,12,14,
     9,3,12,1,15,65,19,64,19,28,22,110,19,41,25,43,