match_bytecode.txt

>>> dis.dis(bench_match.mapping_match_logical)
 63           0 LOAD_CONST               1 ('🐓')
              2 LOAD_CONST               2 (1)
              4 BUILD_MAP                1

 64           6 LOAD_CONST               2 (1)
              8 LOAD_CONST               2 (1)
             10 LOAD_CONST               3 (('🦊', '🌽'))
             12 BUILD_CONST_KEY_MAP      2

 65          14 LOAD_CONST               2 (1)
             16 LOAD_CONST               2 (1)
             18 LOAD_CONST               4 (('🐓', '🌽'))
             20 BUILD_CONST_KEY_MAP      2

 66          22 LOAD_CONST               2 (1)
             24 LOAD_CONST               2 (1)
             26 LOAD_CONST               5 (('🐓', '🦊'))
             28 BUILD_CONST_KEY_MAP      2

 62          30 BUILD_LIST               4
             32 STORE_FAST               0 (boats)

 68          34 LOAD_CONST               6 (0)
             36 STORE_FAST               1 (problems)

 69          38 LOAD_CONST               6 (0)
             40 STORE_FAST               2 (valid_boats)

 70          42 LOAD_GLOBAL              0 (range)
             44 LOAD_CONST               7 (100000)
             46 CALL_FUNCTION            1
             48 GET_ITER
        >>   50 FOR_ITER                42 (to 136)
             52 STORE_FAST               3 (_)

 71          54 LOAD_FAST                0 (boats)
             56 GET_ITER
        >>   58 FOR_ITER                37 (to 134)
             60 STORE_FAST               4 (boat)

 72          62 LOAD_GLOBAL              1 (isinstance)
             64 LOAD_FAST                4 (boat)
             66 LOAD_GLOBAL              2 (Mapping)
             68 CALL_FUNCTION            2
             70 POP_JUMP_IF_FALSE       66 (to 132)

 73          72 LOAD_CONST               1 ('🐓')
             74 LOAD_FAST                4 (boat)
             76 CONTAINS_OP              0
             78 POP_JUMP_IF_FALSE       49 (to 98)
             80 LOAD_CONST               8 ('🌽')
             82 LOAD_FAST                4 (boat)
             84 CONTAINS_OP              0
             86 POP_JUMP_IF_FALSE       49 (to 98)

 74          88 LOAD_FAST                1 (problems)
             90 LOAD_CONST               2 (1)
             92 INPLACE_ADD
             94 STORE_FAST               1 (problems)
             96 JUMP_ABSOLUTE           29 (to 58)

 75     >>   98 LOAD_CONST               1 ('🐓')
            100 LOAD_FAST                4 (boat)
            102 CONTAINS_OP              0
            104 POP_JUMP_IF_FALSE       62 (to 124)
            106 LOAD_CONST               9 ('🦊')
            108 LOAD_FAST                4 (boat)
            110 CONTAINS_OP              0
            112 POP_JUMP_IF_FALSE       62 (to 124)

 76         114 LOAD_FAST                1 (problems)
            116 LOAD_CONST               2 (1)
            118 INPLACE_ADD
            120 STORE_FAST               1 (problems)
            122 JUMP_ABSOLUTE           29 (to 58)

 78     >>  124 LOAD_FAST                2 (valid_boats)
            126 LOAD_CONST               2 (1)
            128 INPLACE_ADD
            130 STORE_FAST               2 (valid_boats)
        >>  132 JUMP_ABSOLUTE           29 (to 58)

 71     >>  134 JUMP_ABSOLUTE           25 (to 50)

 81     >>  136 LOAD_FAST                2 (valid_boats)
            138 LOAD_CONST              10 (200000)
            140 COMPARE_OP               2 (==)
            142 POP_JUMP_IF_TRUE        74 (to 148)
            144 LOAD_ASSERTION_ERROR
            146 RAISE_VARARGS            1

 82     >>  148 LOAD_FAST                1 (problems)
            150 LOAD_CONST              10 (200000)
            152 COMPARE_OP               2 (==)
            154 POP_JUMP_IF_TRUE        80 (to 160)
            156 LOAD_ASSERTION_ERROR
            158 RAISE_VARARGS            1
        >>  160 LOAD_CONST              11 (None)
            162 RETURN_VALUE
>>> dis.dis(bench_match.mapping_match_statement)
 87           0 LOAD_CONST               1 ('🐓')
              2 LOAD_CONST               2 (1)
              4 BUILD_MAP                1

 88           6 LOAD_CONST               2 (1)
              8 LOAD_CONST               2 (1)
             10 LOAD_CONST               3 (('🦊', '🌽'))
             12 BUILD_CONST_KEY_MAP      2

 89          14 LOAD_CONST               2 (1)
             16 LOAD_CONST               2 (1)
             18 LOAD_CONST               4 (('🐓', '🌽'))
             20 BUILD_CONST_KEY_MAP      2

 90          22 LOAD_CONST               2 (1)
             24 LOAD_CONST               2 (1)
             26 LOAD_CONST               5 (('🐓', '🦊'))
             28 BUILD_CONST_KEY_MAP      2

 86          30 BUILD_LIST               4
             32 STORE_FAST               0 (boats)

 92          34 LOAD_CONST               6 (0)
             36 STORE_FAST               1 (problems)

 93          38 LOAD_CONST               6 (0)
             40 STORE_FAST               2 (valid_boats)

 94          42 LOAD_GLOBAL              0 (range)
             44 LOAD_CONST               7 (100000)
             46 CALL_FUNCTION            1
             48 GET_ITER
        >>   50 FOR_ITER                54 (to 160)
             52 STORE_FAST               3 (_)

 95          54 LOAD_FAST                0 (boats)
             56 GET_ITER
        >>   58 FOR_ITER                49 (to 158)
             60 STORE_FAST               4 (boat)

 96          62 LOAD_FAST                4 (boat)

 97          64 DUP_TOP
             66 MATCH_MAPPING
             68 POP_JUMP_IF_FALSE       53 (to 106)
             70 GET_LEN
             72 LOAD_CONST               8 (2)
             74 COMPARE_OP               5 (>=)
             76 POP_JUMP_IF_FALSE       53 (to 106)
             78 LOAD_CONST               4 (('🐓', '🌽'))
             80 MATCH_KEYS
             82 POP_JUMP_IF_FALSE       51 (to 102)
             84 POP_TOP
             86 POP_TOP
             88 POP_TOP
             90 POP_TOP
             92 LOAD_FAST                1 (problems)
             94 LOAD_CONST               2 (1)
             96 INPLACE_ADD
             98 STORE_FAST               1 (problems)
            100 JUMP_ABSOLUTE           29 (to 58)
        >>  102 POP_TOP
            104 POP_TOP
        >>  106 POP_TOP

 98         108 MATCH_MAPPING
            110 POP_JUMP_IF_FALSE       73 (to 146)
            112 GET_LEN
            114 LOAD_CONST               8 (2)
            116 COMPARE_OP               5 (>=)
            118 POP_JUMP_IF_FALSE       73 (to 146)
            120 LOAD_CONST               5 (('🐓', '🦊'))
            122 MATCH_KEYS
            124 POP_JUMP_IF_FALSE       71 (to 142)
            126 POP_TOP
            128 POP_TOP
            130 POP_TOP
            132 LOAD_FAST                1 (problems)
            134 LOAD_CONST               2 (1)
            136 INPLACE_ADD
            138 STORE_FAST               1 (problems)
            140 JUMP_ABSOLUTE           29 (to 58)
        >>  142 POP_TOP
            144 POP_TOP
        >>  146 POP_TOP

 99         148 LOAD_FAST                2 (valid_boats)
            150 LOAD_CONST               2 (1)
            152 INPLACE_ADD
            154 STORE_FAST               2 (valid_boats)
            156 JUMP_ABSOLUTE           29 (to 58)

 95     >>  158 JUMP_ABSOLUTE           25 (to 50)

101     >>  160 LOAD_FAST                2 (valid_boats)
            162 LOAD_CONST              11 (200000)
            164 COMPARE_OP               2 (==)
            166 POP_JUMP_IF_TRUE        86 (to 172)
            168 LOAD_ASSERTION_ERROR
            170 RAISE_VARARGS            1

102     >>  172 LOAD_FAST                1 (problems)
            174 LOAD_CONST              11 (200000)
            176 COMPARE_OP               2 (==)
            178 POP_JUMP_IF_TRUE        92 (to 184)
            180 LOAD_ASSERTION_ERROR
            182 RAISE_VARARGS            1
        >>  184 LOAD_CONST              12 (None)
            186 RETURN_VALUE