bpo-24340: Fix estimation of the code stack size. (#5076)

Lib/test/test_compile.py

@@ -672,7 +672,7 @@ if 1:
         compile("42", PathLike("test_compile_pathlike"), "single")
 
 
-class TestStackSize(unittest.TestCase):
+class TestExpressionStackSize(unittest.TestCase):
     # These tests check that the computed stack size for a code object
     # stays within reasonable bounds (see issue #21523 for an example
     # dysfunction).
@@ -710,5 +710,294 @@ class TestStackSize(unittest.TestCase):
         self.check_stack_size(code)
 
 
+class TestStackSizeStability(unittest.TestCase):
+    # Check that repeating certain snippets doesn't increase the stack size
+    # beyond what a single snippet requires.
+
+    def check_stack_size(self, snippet, async_=False):
+        def compile_snippet(i):
+            ns = {}
+            script = """def func():\n""" + i * snippet
+            if async_:
+                script = "async " + script
+            code = compile(script, "<script>", "exec")
+            exec(code, ns, ns)
+            return ns['func'].__code__
+
+        sizes = [compile_snippet(i).co_stacksize for i in range(2, 5)]
+        if len(set(sizes)) != 1:
+            import dis, io
+            out = io.StringIO()
+            dis.dis(compile_snippet(1), file=out)
+            self.fail("stack sizes diverge with # of consecutive snippets: "
+                      "%s\n%s\n%s" % (sizes, snippet, out.getvalue()))
+
+    def test_if(self):
+        snippet = """
+            if x:
+                a
+            """
+        self.check_stack_size(snippet)
+
+    def test_if_else(self):
+        snippet = """
+            if x:
+                a
+            elif y:
+                b
+            else:
+                c
+            """
+        self.check_stack_size(snippet)
+
+    def test_try_except_bare(self):
+        snippet = """
+            try:
+                a
+            except:
+                b
+            """
+        self.check_stack_size(snippet)
+
+    def test_try_except_qualified(self):
+        snippet = """
+            try:
+                a
+            except ImportError:
+                b
+            except:
+                c
+            else:
+                d
+            """
+        self.check_stack_size(snippet)
+
+    def test_try_except_as(self):
+        snippet = """
+            try:
+                a
+            except ImportError as e:
+                b
+            except:
+                c
+            else:
+                d
+            """
+        self.check_stack_size(snippet)
+
+    def test_try_finally(self):
+        snippet = """
+                try:
+                    a
+                finally:
+                    b
+            """
+        self.check_stack_size(snippet)
+
+    def test_with(self):
+        snippet = """
+            with x as y:
+                a
+            """
+        self.check_stack_size(snippet)
+
+    def test_while_else(self):
+        snippet = """
+            while x:
+                a
+            else:
+                b
+            """
+        self.check_stack_size(snippet)
+
+    def test_for(self):
+        snippet = """
+            for x in y:
+                a
+            """
+        self.check_stack_size(snippet)
+
+    def test_for_else(self):
+        snippet = """
+            for x in y:
+                a
+            else:
+                b
+            """
+        self.check_stack_size(snippet)
+
+    def test_for_break_continue(self):
+        snippet = """
+            for x in y:
+                if z:
+                    break
+                elif u:
+                    continue
+                else:
+                    a
+            else:
+                b
+            """
+        self.check_stack_size(snippet)
+
+    def test_for_break_continue_inside_try_finally_block(self):
+        snippet = """
+            for x in y:
+                try:
+                    if z:
+                        break
+                    elif u:
+                        continue
+                    else:
+                        a
+                finally:
+                    f
+            else:
+                b
+            """
+        self.check_stack_size(snippet)
+
+    def test_for_break_inside_finally_block(self):
+        snippet = """
+            for x in y:
+                try:
+                    t
+                finally:
+                    if z:
+                        break
+                    else:
+                        a
+            else:
+                b
+            """
+        self.check_stack_size(snippet)
+
+    def test_for_break_continue_inside_except_block(self):
+        snippet = """
+            for x in y:
+                try:
+                    t
+                except:
+                    if z:
+                        break
+                    elif u:
+                        continue
+                    else:
+                        a
+            else:
+                b
+            """
+        self.check_stack_size(snippet)
+
+    def test_for_break_continue_inside_with_block(self):
+        snippet = """
+            for x in y:
+                with c:
+                    if z:
+                        break
+                    elif u:
+                        continue
+                    else:
+                        a
+            else:
+                b
+            """
+        self.check_stack_size(snippet)
+
+    def test_return_inside_try_finally_block(self):
+        snippet = """
+            try:
+                if z:
+                    return
+                else:
+                    a
+            finally:
+                f
+            """
+        self.check_stack_size(snippet)
+
+    def test_return_inside_finally_block(self):
+        snippet = """
+            try:
+                t
+            finally:
+                if z:
+                    return
+                else:
+                    a
+            """
+        self.check_stack_size(snippet)
+
+    def test_return_inside_except_block(self):
+        snippet = """
+            try:
+                t
+            except:
+                if z:
+                    return
+                else:
+                    a
+            """
+        self.check_stack_size(snippet)
+
+    def test_return_inside_with_block(self):
+        snippet = """
+            with c:
+                if z:
+                    return
+                else:
+                    a
+            """
+        self.check_stack_size(snippet)
+
+    def test_async_with(self):
+        snippet = """
+            async with x as y:
+                a
+            """
+        self.check_stack_size(snippet, async_=True)
+
+    def test_async_for(self):
+        snippet = """
+            async for x in y:
+                a
+            """
+        self.check_stack_size(snippet, async_=True)
+
+    def test_async_for_else(self):
+        snippet = """
+            async for x in y:
+                a
+            else:
+                b
+            """
+        self.check_stack_size(snippet, async_=True)
+
+    def test_for_break_continue_inside_async_with_block(self):
+        snippet = """
+            for x in y:
+                async with c:
+                    if z:
+                        break
+                    elif u:
+                        continue
+                    else:
+                        a
+            else:
+                b
+            """
+        self.check_stack_size(snippet, async_=True)
+
+    def test_return_inside_async_with_block(self):
+        snippet = """
+            async with c:
+                if z:
+                    return
+                else:
+                    a
+            """
+        self.check_stack_size(snippet, async_=True)
+
+
 if __name__ == "__main__":
     unittest.main()

Lib/test/test_dis.py

@@ -284,18 +284,18 @@ dis_traceback = """\
              22 POP_TOP
              24 STORE_FAST               0 (e)
              26 POP_TOP
-             28 SETUP_FINALLY           12 (to 42)
+             28 SETUP_FINALLY           10 (to 40)
 
 %3d          30 LOAD_FAST                0 (e)
              32 LOAD_ATTR                1 (__traceback__)
              34 STORE_FAST               1 (tb)
              36 POP_BLOCK
-             38 POP_EXCEPT
+             38 LOAD_CONST               0 (None)
-             40 LOAD_CONST               0 (None)
+        >>   40 LOAD_CONST               0 (None)
-        >>   42 LOAD_CONST               0 (None)
+             42 STORE_FAST               0 (e)
-             44 STORE_FAST               0 (e)
+             44 DELETE_FAST              0 (e)
-             46 DELETE_FAST              0 (e)
+             46 END_FINALLY
-             48 END_FINALLY
+             48 POP_EXCEPT
              50 JUMP_FORWARD             2 (to 54)
         >>   52 END_FINALLY
 
@@ -741,7 +741,7 @@ Filename:          (.*)
 Argument count:    0
 Kw-only arguments: 0
 Number of locals:  2
-Stack size:        17
+Stack size:        10
 Flags:             OPTIMIZED, NEWLOCALS, NOFREE, COROUTINE
 Constants:
    0: None

Misc/NEWS.d/next/Core and Builtins/2018-01-01-21-59-31.bpo-24340.hmKBvg.rst

@@ -0,0 +1 @@
+Fixed estimation of the code stack size.

Python/compile.c

@@ -857,10 +857,22 @@ compiler_set_lineno(struct compiler *c, int off)
     b->b_instr[off].i_lineno = c->u->u_lineno;
 }
 
-int
+/* Return the stack effect of opcode with argument oparg.
-PyCompile_OpcodeStackEffect(int opcode, int oparg)
+
+   Some opcodes have different stack effect when jump to the target and
+   when not jump. The 'jump' parameter specifies the case:
+
+   * 0 -- when not jump
+   * 1 -- when jump
+   * -1 -- maximal
+ */
+/* XXX Make the stack effect of WITH_CLEANUP_START and
+   WITH_CLEANUP_FINISH deterministic. */
+static int
+stack_effect(int opcode, int oparg, int jump)
 {
     switch (opcode) {
+        /* Stack manipulation */
         case POP_TOP:
             return -1;
         case ROT_TWO:
@@ -871,6 +883,7 @@ PyCompile_OpcodeStackEffect(int opcode, int oparg)
         case DUP_TOP_TWO:
             return 2;
 
+        /* Unary operators */
         case UNARY_POSITIVE:
         case UNARY_NEGATIVE:
         case UNARY_NOT:
@@ -883,6 +896,7 @@ PyCompile_OpcodeStackEffect(int opcode, int oparg)
         case MAP_ADD:
             return -2;
 
+        /* Binary operators */
         case BINARY_POWER:
         case BINARY_MULTIPLY:
         case BINARY_MATRIX_MULTIPLY:
@@ -932,11 +946,16 @@ PyCompile_OpcodeStackEffect(int opcode, int oparg)
         case BREAK_LOOP:
             return 0;
         case SETUP_WITH:
-            return 7;
+            /* 1 in the normal flow.
+             * Restore the stack position and push 6 values before jumping to
+             * the handler if an exception be raised. */
+            return jump ? 6 : 1;
         case WITH_CLEANUP_START:
-            return 1;
+            return 2; /* or 1, depending on TOS */
         case WITH_CLEANUP_FINISH:
-            return -1; /* XXX Sometimes more */
+            /* Pop a variable number of values pushed by WITH_CLEANUP_START
+             * + __exit__ or __aexit__. */
+            return -3;
         case RETURN_VALUE:
             return -1;
         case IMPORT_STAR:
@@ -950,9 +969,10 @@ PyCompile_OpcodeStackEffect(int opcode, int oparg)
         case POP_BLOCK:
             return 0;
         case POP_EXCEPT:
-            return 0;  /* -3 except if bad bytecode */
+            return -3;
         case END_FINALLY:
-            return -1; /* or -2 or -3 if exception occurred */
+            /* Pop 6 values when an exception was raised. */
+            return -6;
 
         case STORE_NAME:
             return -1;
@@ -963,7 +983,8 @@ PyCompile_OpcodeStackEffect(int opcode, int oparg)
         case UNPACK_EX:
             return (oparg&0xFF) + (oparg>>8);
         case FOR_ITER:
-            return 1; /* or -1, at end of iterator */
+            /* -1 at end of iterator, 1 if continue iterating. */
+            return jump > 0 ? -1 : 1;
 
         case STORE_ATTR:
             return -2;
@@ -1002,12 +1023,15 @@ PyCompile_OpcodeStackEffect(int opcode, int oparg)
         case IMPORT_FROM:
             return 1;
 
+        /* Jumps */
         case JUMP_FORWARD:
-        case JUMP_IF_TRUE_OR_POP:  /* -1 if jump not taken */
-        case JUMP_IF_FALSE_OR_POP:  /*  "" */
         case JUMP_ABSOLUTE:
             return 0;
 
+        case JUMP_IF_TRUE_OR_POP:
+        case JUMP_IF_FALSE_OR_POP:
+            return jump ? 0 : -1;
+
         case POP_JUMP_IF_FALSE:
         case POP_JUMP_IF_TRUE:
             return -1;
@@ -1021,8 +1045,10 @@ PyCompile_OpcodeStackEffect(int opcode, int oparg)
             return 0;
         case SETUP_EXCEPT:
         case SETUP_FINALLY:
-            return 6; /* can push 3 values for the new exception
+            /* 0 in the normal flow.
-                + 3 others for the previous exception state */
+             * Restore the stack position and push 6 values before jumping to
+             * the handler if an exception be raised. */
+            return jump ? 6 : 0;
 
         case LOAD_FAST:
             return 1;
@@ -1035,6 +1061,8 @@ PyCompile_OpcodeStackEffect(int opcode, int oparg)
 
         case RAISE_VARARGS:
             return -oparg;
+
+        /* Functions and calls */
         case CALL_FUNCTION:
             return -oparg;
         case CALL_METHOD:
@@ -1052,6 +1080,7 @@ PyCompile_OpcodeStackEffect(int opcode, int oparg)
             else
                 return -1;
 
+        /* Closures */
         case LOAD_CLOSURE:
             return 1;
         case LOAD_DEREF:
@@ -1061,10 +1090,16 @@ PyCompile_OpcodeStackEffect(int opcode, int oparg)
             return -1;
         case DELETE_DEREF:
             return 0;
+
+        /* Iterators and generators */
         case GET_AWAITABLE:
             return 0;
         case SETUP_ASYNC_WITH:
-            return 6;
+            /* 0 in the normal flow.
+             * Restore the stack position to the position before the result
+             * of __aenter__ and push 6 values before jumping to the handler
+             * if an exception be raised. */
+            return jump ? -1 + 6 : 0;
         case BEFORE_ASYNC_WITH:
             return 1;
         case GET_AITER:
@@ -1085,6 +1120,12 @@ PyCompile_OpcodeStackEffect(int opcode, int oparg)
     return PY_INVALID_STACK_EFFECT; /* not reachable */
 }
 
+int
+PyCompile_OpcodeStackEffect(int opcode, int oparg)
+{
+    return stack_effect(opcode, oparg, -1);
+}
+
 /* Add an opcode with no argument.
    Returns 0 on failure, 1 on success.
 */
@@ -2329,6 +2370,7 @@ compiler_async_for(struct compiler *c, stmt_ty s)
     ADDOP(c, POP_TOP);
     ADDOP(c, POP_TOP);
     ADDOP(c, POP_EXCEPT); /* for SETUP_EXCEPT */
+    ADDOP(c, POP_TOP); /* for correct calculation of stack effect */
     ADDOP(c, POP_BLOCK); /* for SETUP_LOOP */
     ADDOP_JABS(c, JUMP_ABSOLUTE, after_loop_else);
 
@@ -2611,7 +2653,6 @@ compiler_try_except(struct compiler *c, stmt_ty s)
             /* second # body */
             VISIT_SEQ(c, stmt, handler->v.ExceptHandler.body);
             ADDOP(c, POP_BLOCK);
-            ADDOP(c, POP_EXCEPT);
             compiler_pop_fblock(c, FINALLY_TRY, cleanup_body);
 
             /* finally: */
@@ -2628,6 +2669,7 @@ compiler_try_except(struct compiler *c, stmt_ty s)
             compiler_nameop(c, handler->v.ExceptHandler.name, Del);
 
             ADDOP(c, END_FINALLY);
+            ADDOP(c, POP_EXCEPT);
             compiler_pop_fblock(c, FINALLY_END, cleanup_end);
         }
         else {
@@ -4899,44 +4941,55 @@ dfs(struct compiler *c, basicblock *b, struct assembler *a)
 static int
 stackdepth_walk(struct compiler *c, basicblock *b, int depth, int maxdepth)
 {
-    int i, target_depth, effect;
+    int i, new_depth, target_depth, effect;
     struct instr *instr;
-    if (b->b_seen || b->b_startdepth >= depth)
+    assert(!b->b_seen || b->b_startdepth == depth);
+    if (b->b_seen || b->b_startdepth >= depth) {
         return maxdepth;
+    }
+    /* Guard against infinite recursion */
     b->b_seen = 1;
     b->b_startdepth = depth;
     for (i = 0; i < b->b_iused; i++) {
         instr = &b->b_instr[i];
-        effect = PyCompile_OpcodeStackEffect(instr->i_opcode, instr->i_oparg);
+        effect = stack_effect(instr->i_opcode, instr->i_oparg, 0);
         if (effect == PY_INVALID_STACK_EFFECT) {
             fprintf(stderr, "opcode = %d\n", instr->i_opcode);
             Py_FatalError("PyCompile_OpcodeStackEffect()");
         }
-        depth += effect;
+        new_depth = depth + effect;
-
+        if (new_depth > maxdepth) {
-        if (depth > maxdepth)
+            maxdepth = new_depth;
-            maxdepth = depth;
+        }
-        assert(depth >= 0); /* invalid code or bug in stackdepth() */
+        assert(new_depth >= 0); /* invalid code or bug in stackdepth() */
         if (instr->i_jrel || instr->i_jabs) {
-            target_depth = depth;
+            /* Recursively inspect jump target */
-            if (instr->i_opcode == FOR_ITER) {
+            effect = stack_effect(instr->i_opcode, instr->i_oparg, 1);
-                target_depth = depth-2;
+            assert(effect != PY_INVALID_STACK_EFFECT);
+            target_depth = depth + effect;
+            if (target_depth > maxdepth) {
+                maxdepth = target_depth;
             }
-            else if (instr->i_opcode == SETUP_FINALLY ||
+            assert(target_depth >= 0); /* invalid code or bug in stackdepth() */
-                     instr->i_opcode == SETUP_EXCEPT) {
+            if (instr->i_opcode == CONTINUE_LOOP) {
-                target_depth = depth+3;
+                /* Pops a variable number of values from the stack,
-                if (target_depth > maxdepth)
+                 * but the target should be already proceeding.
-                    maxdepth = target_depth;
+                 */
-            }
+                assert(instr->i_target->b_seen);
-            else if (instr->i_opcode == JUMP_IF_TRUE_OR_POP ||
+                assert(instr->i_target->b_startdepth <= depth);
-                     instr->i_opcode == JUMP_IF_FALSE_OR_POP)
-                depth = depth - 1;
-            maxdepth = stackdepth_walk(c, instr->i_target,
-                                       target_depth, maxdepth);
-            if (instr->i_opcode == JUMP_ABSOLUTE ||
-                instr->i_opcode == JUMP_FORWARD) {
                 goto out; /* remaining code is dead */
             }
+            maxdepth = stackdepth_walk(c, instr->i_target,
+                                       target_depth, maxdepth);
+        }
+        depth = new_depth;
+        if (instr->i_opcode == JUMP_ABSOLUTE ||
+            instr->i_opcode == JUMP_FORWARD ||
+            instr->i_opcode == RETURN_VALUE ||
+            instr->i_opcode == RAISE_VARARGS ||
+            instr->i_opcode == BREAK_LOOP)
+        {
+            goto out; /* remaining code is dead */
         }
     }
     if (b->b_next)

Python/importlib.h

@@ -133,7 +133,7 @@ const unsigned char _Py_M__importlib[] = {
     1,10,1,8,1,4,1,6,1,8,1,122,24,95,77,111,
     100,117,108,101,76,111,99,107,46,104,97,115,95,100,101,97,
     100,108,111,99,107,99,1,0,0,0,0,0,0,0,2,0,
-    0,0,16,0,0,0,67,0,0,0,115,168,0,0,0,116,
+    0,0,9,0,0,0,67,0,0,0,115,168,0,0,0,116,
     0,160,1,161,0,125,1,124,0,116,2,124,1,60,0,122,
     138,120,132,124,0,106,3,143,96,1,0,124,0,106,4,100,
     1,107,2,115,48,124,0,106,5,124,1,107,2,114,72,124,
@@ -169,7 +169,7 @@ const unsigned char _Py_M__importlib[] = {
     1,2,1,8,1,20,1,6,1,14,1,4,1,8,1,12,
     1,12,1,24,2,10,1,18,2,122,19,95,77,111,100,117,
     108,101,76,111,99,107,46,97,99,113,117,105,114,101,99,1,
-    0,0,0,0,0,0,0,2,0,0,0,10,0,0,0,67,
+    0,0,0,0,0,0,0,2,0,0,0,9,0,0,0,67,
     0,0,0,115,122,0,0,0,116,0,160,1,161,0,125,1,
     124,0,106,2,143,98,1,0,124,0,106,3,124,1,107,3,
     114,34,116,4,100,1,131,1,130,1,124,0,106,5,100,2,
@@ -300,7 +300,7 @@ const unsigned char _Py_M__importlib[] = {
     0,114,10,0,0,0,114,11,0,0,0,114,42,0,0,0,
     141,0,0,0,115,6,0,0,0,8,2,8,4,8,4,114,
     42,0,0,0,99,1,0,0,0,0,0,0,0,3,0,0,
-    0,18,0,0,0,67,0,0,0,115,130,0,0,0,116,0,
+    0,8,0,0,0,67,0,0,0,115,130,0,0,0,116,0,
     160,1,161,0,1,0,122,106,121,14,116,2,124,0,25,0,
     131,0,125,1,87,0,110,24,4,0,116,3,107,10,114,48,
     1,0,1,0,1,0,100,1,125,1,89,0,110,2,88,0,
@@ -318,7 +318,7 @@ const unsigned char _Py_M__importlib[] = {
     108,111,98,97,108,32,105,109,112,111,114,116,32,108,111,99,
     107,32,116,111,32,112,114,111,116,101,99,116,10,32,32,32,
     32,95,109,111,100,117,108,101,95,108,111,99,107,115,46,78,
-    99,2,0,0,0,0,0,0,0,2,0,0,0,11,0,0,
+    99,2,0,0,0,0,0,0,0,2,0,0,0,8,0,0,
     0,83,0,0,0,115,48,0,0,0,116,0,160,1,161,0,
     1,0,122,24,116,2,160,3,124,1,161,1,124,0,107,8,
     114,30,116,2,124,1,61,0,87,0,100,0,116,0,160,4,
@@ -340,7 +340,7 @@ const unsigned char _Py_M__importlib[] = {
     0,0,0,114,45,0,0,0,157,0,0,0,115,28,0,0,
     0,0,6,8,1,2,1,2,1,14,1,14,1,10,2,8,
     1,8,1,10,2,8,2,12,11,20,2,10,2,114,45,0,
-    0,0,99,1,0,0,0,0,0,0,0,2,0,0,0,11,
+    0,0,99,1,0,0,0,0,0,0,0,2,0,0,0,8,
     0,0,0,67,0,0,0,115,54,0,0,0,116,0,124,0,
     131,1,125,1,121,12,124,1,160,1,161,0,1,0,87,0,
     110,20,4,0,116,2,107,10,114,40,1,0,1,0,1,0,
@@ -488,7 +488,7 @@ const unsigned char _Py_M__importlib[] = {
     0,0,0,218,17,95,108,111,97,100,95,109,111,100,117,108,
     101,95,115,104,105,109,253,0,0,0,115,12,0,0,0,0,
     6,10,1,10,1,10,1,10,1,10,2,114,84,0,0,0,
-    99,1,0,0,0,0,0,0,0,5,0,0,0,36,0,0,
+    99,1,0,0,0,0,0,0,0,5,0,0,0,8,0,0,
     0,67,0,0,0,115,216,0,0,0,116,0,124,0,100,1,
     100,0,131,3,125,1,116,1,124,1,100,2,131,2,114,54,
     121,10,124,1,160,2,124,0,161,1,83,0,4,0,116,3,
@@ -548,7 +548,7 @@ const unsigned char _Py_M__importlib[] = {
     0,0,115,4,0,0,0,0,4,8,1,122,27,95,105,110,
     115,116,97,108,108,101,100,95,115,97,102,101,108,121,46,95,
     95,101,110,116,101,114,95,95,99,1,0,0,0,0,0,0,
-    0,3,0,0,0,17,0,0,0,71,0,0,0,115,98,0,
+    0,3,0,0,0,8,0,0,0,71,0,0,0,115,98,0,
     0,0,122,82,124,0,106,0,125,2,116,1,100,1,100,2,
     132,0,124,1,68,0,131,1,131,1,114,64,121,14,116,2,
     106,3,124,2,106,4,61,0,87,0,113,80,4,0,116,5,
@@ -723,7 +723,7 @@ const unsigned char _Py_M__importlib[] = {
     0,0,0,0,1,10,1,14,1,10,1,18,1,10,1,8,
     1,10,1,122,19,77,111,100,117,108,101,83,112,101,99,46,
     95,95,114,101,112,114,95,95,99,2,0,0,0,0,0,0,
-    0,3,0,0,0,11,0,0,0,67,0,0,0,115,102,0,
+    0,3,0,0,0,8,0,0,0,67,0,0,0,115,102,0,
     0,0,124,0,106,0,125,2,121,70,124,0,106,1,124,1,
     106,1,107,2,111,76,124,0,106,2,124,1,106,2,107,2,
     111,76,124,0,106,3,124,1,106,3,107,2,111,76,124,2,
@@ -793,7 +793,7 @@ const unsigned char _Py_M__importlib[] = {
     0,0,0,76,1,0,0,115,18,0,0,0,12,37,4,1,
     14,11,8,10,8,12,12,9,14,4,12,8,12,4,114,102,
     0,0,0,41,2,114,103,0,0,0,114,105,0,0,0,99,
-    2,0,0,0,2,0,0,0,6,0,0,0,14,0,0,0,
+    2,0,0,0,2,0,0,0,6,0,0,0,8,0,0,0,
     67,0,0,0,115,154,0,0,0,116,0,124,1,100,1,131,
     2,114,74,116,1,100,2,107,8,114,22,116,2,130,1,116,
     1,106,3,125,4,124,3,100,2,107,8,114,48,124,4,124,
@@ -821,7 +821,7 @@ const unsigned char _Py_M__importlib[] = {
     177,1,0,0,115,34,0,0,0,0,2,10,1,8,1,4,
     1,6,2,8,1,12,1,12,1,6,1,8,2,8,1,10,
     1,2,1,14,1,14,1,12,3,4,2,114,78,0,0,0,
-    99,3,0,0,0,0,0,0,0,8,0,0,0,53,0,0,
+    99,3,0,0,0,0,0,0,0,8,0,0,0,8,0,0,
     0,67,0,0,0,115,56,1,0,0,121,10,124,0,106,0,
     125,3,87,0,110,20,4,0,116,1,107,10,114,30,1,0,
     1,0,1,0,89,0,110,14,88,0,124,3,100,0,107,9,
@@ -860,7 +860,7 @@ const unsigned char _Py_M__importlib[] = {
     14,1,10,1,2,1,14,1,16,1,10,2,14,1,20,1,
     6,1,6,1,114,128,0,0,0,70,41,1,218,8,111,118,
     101,114,114,105,100,101,99,2,0,0,0,1,0,0,0,5,
-    0,0,0,59,0,0,0,67,0,0,0,115,212,1,0,0,
+    0,0,0,8,0,0,0,67,0,0,0,115,212,1,0,0,
     124,2,115,20,116,0,124,1,100,1,100,0,131,3,100,0,
     107,8,114,54,121,12,124,0,106,1,124,1,95,2,87,0,
     110,20,4,0,116,3,107,10,114,52,1,0,1,0,1,0,
@@ -956,7 +956,7 @@ const unsigned char _Py_M__importlib[] = {
     0,0,0,114,10,0,0,0,114,11,0,0,0,114,91,0,
     0,0,69,2,0,0,115,16,0,0,0,0,3,20,1,10,
     1,10,1,10,2,16,2,6,1,14,2,114,91,0,0,0,
-    99,2,0,0,0,0,0,0,0,4,0,0,0,12,0,0,
+    99,2,0,0,0,0,0,0,0,4,0,0,0,9,0,0,
     0,67,0,0,0,115,178,0,0,0,124,0,106,0,125,2,
     116,1,124,2,131,1,143,148,1,0,116,2,106,3,160,4,
     124,2,161,1,124,1,107,9,114,54,100,1,160,5,124,2,
@@ -988,7 +988,7 @@ const unsigned char _Py_M__importlib[] = {
     86,2,0,0,115,30,0,0,0,0,2,6,1,10,1,16,
     1,10,1,12,1,10,1,10,1,14,2,14,1,4,1,14,
     1,12,4,14,2,22,1,114,80,0,0,0,99,1,0,0,
-    0,0,0,0,0,2,0,0,0,27,0,0,0,67,0,0,
+    0,0,0,0,0,2,0,0,0,8,0,0,0,67,0,0,
     0,115,206,0,0,0,124,0,106,0,160,1,124,0,106,2,
     161,1,1,0,116,3,106,4,124,0,106,2,25,0,125,1,
     116,5,124,1,100,1,100,0,131,3,100,0,107,8,114,76,
@@ -1016,7 +1016,7 @@ const unsigned char _Py_M__importlib[] = {
     1,12,1,14,1,6,1,16,1,2,4,8,1,10,1,22,
     1,14,1,6,1,16,1,2,1,10,1,14,1,6,1,114,
     139,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,118,0,0,0,124,0,
+    0,9,0,0,0,67,0,0,0,115,118,0,0,0,124,0,
     106,0,100,0,107,9,114,30,116,1,124,0,106,0,100,1,
     131,2,115,30,116,2,124,0,131,1,83,0,116,3,124,0,
     131,1,125,1,116,4,124,1,131,1,143,54,1,0,124,0,
@@ -1406,7 +1406,7 @@ const unsigned char _Py_M__importlib[] = {
     0,114,11,0,0,0,218,17,95,102,105,110,100,95,115,112,
     101,99,95,108,101,103,97,99,121,93,3,0,0,115,8,0,
     0,0,0,3,12,1,8,1,4,1,114,164,0,0,0,99,
-    3,0,0,0,0,0,0,0,10,0,0,0,27,0,0,0,
+    3,0,0,0,0,0,0,0,10,0,0,0,10,0,0,0,
     67,0,0,0,115,240,0,0,0,116,0,106,1,125,3,124,
     3,100,1,107,8,114,22,116,2,100,2,131,1,130,1,124,
     3,115,38,116,3,160,4,100,3,116,5,161,2,1,0,124,
@@ -1475,7 +1475,7 @@ const unsigned char _Py_M__importlib[] = {
     1,8,1,10,1,10,1,4,1,8,2,12,1,114,173,0,
     0,0,122,16,78,111,32,109,111,100,117,108,101,32,110,97,
     109,101,100,32,122,4,123,33,114,125,99,2,0,0,0,0,
-    0,0,0,8,0,0,0,13,0,0,0,67,0,0,0,115,
+    0,0,0,8,0,0,0,8,0,0,0,67,0,0,0,115,
     220,0,0,0,100,0,125,2,124,0,160,0,100,1,161,1,
     100,2,25,0,125,3,124,3,114,134,124,3,116,1,106,2,
     107,7,114,42,116,3,124,1,124,3,131,2,1,0,124,0,
@@ -1508,7 +1508,7 @@ const unsigned char _Py_M__importlib[] = {
     4,1,14,1,4,1,10,1,10,2,10,1,10,1,10,1,
     2,1,10,1,14,1,16,1,20,1,10,1,8,1,20,2,
     8,1,4,2,10,1,22,1,114,178,0,0,0,99,2,0,
-    0,0,0,0,0,0,4,0,0,0,11,0,0,0,67,0,
+    0,0,0,0,0,0,4,0,0,0,9,0,0,0,67,0,
     0,0,115,94,0,0,0,116,0,124,0,131,1,143,38,1,
     0,116,1,106,2,160,3,124,0,116,4,161,2,125,2,124,
     2,116,4,107,8,114,42,116,5,124,0,124,1,131,2,83,
@@ -1560,7 +1560,7 @@ const unsigned char _Py_M__importlib[] = {
     114,10,0,0,0,114,11,0,0,0,114,181,0,0,0,214,
     3,0,0,115,8,0,0,0,0,9,12,1,8,1,12,1,
     114,181,0,0,0,41,1,218,9,114,101,99,117,114,115,105,
-    118,101,99,3,0,0,0,1,0,0,0,8,0,0,0,17,
+    118,101,99,3,0,0,0,1,0,0,0,8,0,0,0,11,
     0,0,0,67,0,0,0,115,234,0,0,0,116,0,124,0,
     100,1,131,2,114,230,120,218,124,1,68,0,93,210,125,4,
     116,1,124,4,116,2,131,2,115,78,124,3,114,46,124,0,
@@ -1572,10 +1572,10 @@ const unsigned char _Py_M__importlib[] = {
     1,0,113,16,116,0,124,0,124,4,131,2,115,16,100,10,
     160,8,124,0,106,3,124,4,161,2,125,6,121,14,116,9,
     124,2,124,6,131,2,1,0,87,0,113,16,4,0,116,10,
-    107,10,114,224,1,0,125,7,1,0,122,38,124,7,106,11,
+    107,10,114,224,1,0,125,7,1,0,122,36,124,7,106,11,
     124,6,107,2,114,206,116,12,106,13,160,14,124,6,116,15,
-    161,2,100,11,107,9,114,206,119,16,130,0,87,0,89,0,
+    161,2,100,11,107,9,114,206,119,16,130,0,87,0,100,11,
-    100,11,100,11,125,7,126,7,88,0,113,16,88,0,113,16,
+    100,11,125,7,126,7,88,0,89,0,113,16,88,0,113,16,
     87,0,124,0,83,0,41,12,122,238,70,105,103,117,114,101,
     32,111,117,116,32,119,104,97,116,32,95,95,105,109,112,111,
     114,116,95,95,32,115,104,111,117,108,100,32,114,101,116,117,