Please decompile the following Python bytecode.

  9           0 RESUME                   0

 15           2 LOAD_GLOBAL              1 (NULL + Bytecode)
             12 LOAD_ATTR                2 (from_code)
             32 LOAD_FAST                0 (func)
             34 LOAD_ATTR                4 (__code__)
             54 CALL                     1
             62 STORE_FAST               1 (original_bc)

 18          64 LOAD_GLOBAL              7 (NULL + list)
             74 LOAD_FAST                1 (original_bc)
             76 CALL                     1
             84 STORE_FAST               2 (instructions)

 21          86 BUILD_LIST               0
             88 STORE_FAST               3 (loop_stack)

 23          90 BUILD_LIST               0
             92 STORE_FAST               4 (loop_end_positions)

 26          94 LOAD_GLOBAL              9 (NULL + enumerate)
            104 LOAD_FAST                2 (instructions)
            106 CALL                     1
            114 GET_ITER
        >>  116 FOR_ITER                55 (to 230)
            120 UNPACK_SEQUENCE          2
            124 STORE_FAST               5 (idx)
            126 STORE_FAST               6 (instr)

 27         128 LOAD_GLOBAL             11 (NULL + isinstance)
            138 LOAD_FAST                6 (instr)
            140 LOAD_GLOBAL             12 (Instr)
            150 CALL                     2
            158 POP_JUMP_IF_TRUE         1 (to 162)
            160 JUMP_BACKWARD           23 (to 116)

 28     >>  162 LOAD_FAST                6 (instr)
            164 LOAD_ATTR               14 (name)
            184 LOAD_CONST               1 ('END_FOR')
            186 COMPARE_OP              40 (==)
            190 POP_JUMP_IF_TRUE         1 (to 194)
            192 JUMP_BACKWARD           39 (to 116)

 29     >>  194 LOAD_FAST                4 (loop_end_positions)
            196 LOAD_ATTR               17 (NULL|self + append)
            216 LOAD_FAST                5 (idx)
            218 CALL                     1
            226 POP_TOP
            228 JUMP_BACKWARD           57 (to 116)

 26     >>  230 END_FOR

 31         232 LOAD_FAST                4 (loop_end_positions)
            234 POP_JUMP_IF_TRUE        13 (to 262)

 33         236 LOAD_GLOBAL             19 (NULL + print)
            246 LOAD_CONST               2 ('No loops detected in the function. `breakall()` will have no effect.')
            248 CALL                     1
            256 POP_TOP

 34         258 LOAD_FAST                0 (func)
            260 RETURN_VALUE

 37     >>  262 LOAD_FAST                4 (loop_end_positions)
            264 LOAD_CONST               3 (-1)
            266 BINARY_SUBSCR
            270 STORE_FAST               7 (outermost_loop_end_idx)

 40         272 LOAD_GLOBAL             21 (NULL + Label)
            282 CALL                     0
            290 STORE_FAST               8 (breakall_exit_label)

 48         292 BUILD_LIST               0
            294 STORE_FAST               9 (modified_instructions)

 49         296 LOAD_GLOBAL              9 (NULL + enumerate)
            306 LOAD_FAST                2 (instructions)
            308 CALL                     1
            316 GET_ITER
        >>  318 FOR_ITER                45 (to 412)
            322 UNPACK_SEQUENCE          2
            326 STORE_FAST               5 (idx)
            328 STORE_FAST               6 (instr)

 50         330 LOAD_FAST                9 (modified_instructions)
            332 LOAD_ATTR               17 (NULL|self + append)
            352 LOAD_FAST                6 (instr)
            354 CALL                     1
            362 POP_TOP

 51         364 LOAD_FAST                5 (idx)
            366 LOAD_FAST                7 (outermost_loop_end_idx)
            368 COMPARE_OP              40 (==)
            372 POP_JUMP_IF_TRUE         1 (to 376)
            374 JUMP_BACKWARD           29 (to 318)

 53     >>  376 LOAD_FAST                9 (modified_instructions)
            378 LOAD_ATTR               17 (NULL|self + append)
            398 LOAD_FAST                8 (breakall_exit_label)
            400 CALL                     1
            408 POP_TOP
            410 JUMP_BACKWARD           47 (to 318)

 49     >>  412 END_FOR

 56         414 BUILD_LIST               0
            416 STORE_FAST              10 (final_instructions)

 57         418 LOAD_CONST               4 (0)
            420 STORE_FAST              11 (i)

 58     >>  422 LOAD_FAST               11 (i)
            424 LOAD_GLOBAL             23 (NULL + len)
            434 LOAD_FAST                9 (modified_instructions)
            436 CALL                     1
            444 COMPARE_OP               2 (<)
            448 POP_JUMP_IF_FALSE      194 (to 838)

 59     >>  450 LOAD_FAST                9 (modified_instructions)
            452 LOAD_FAST               11 (i)
            454 BINARY_SUBSCR
            458 STORE_FAST               6 (instr)

 62         460 LOAD_GLOBAL             11 (NULL + isinstance)
            470 LOAD_FAST                6 (instr)
            472 LOAD_GLOBAL             12 (Instr)
            482 CALL                     2
            490 POP_JUMP_IF_FALSE      136 (to 764)

 63         492 LOAD_FAST                6 (instr)
            494 LOAD_ATTR               14 (name)
            514 LOAD_CONST               5 ('LOAD_GLOBAL')
            516 COMPARE_OP              40 (==)
            520 POP_JUMP_IF_FALSE      121 (to 764)

 64         522 LOAD_FAST                6 (instr)
            524 LOAD_ATTR               24 (arg)
            544 LOAD_CONST               6 (1)
            546 BINARY_SUBSCR
            550 LOAD_CONST               7 ('breakall')
            552 COMPARE_OP              40 (==)
            556 POP_JUMP_IF_FALSE      103 (to 764)

 67         558 LOAD_FAST               11 (i)
            560 LOAD_CONST               6 (1)
            562 BINARY_OP                0 (+)
            566 LOAD_GLOBAL             23 (NULL + len)
            576 LOAD_FAST                9 (modified_instructions)
            578 CALL                     1
            586 COMPARE_OP               2 (<)
            590 POP_JUMP_IF_FALSE       86 (to 764)

 68         592 LOAD_FAST                9 (modified_instructions)
            594 LOAD_FAST               11 (i)
            596 LOAD_CONST               6 (1)
            598 BINARY_OP                0 (+)
            602 BINARY_SUBSCR
            606 STORE_FAST              12 (next_instr)

 70         608 LOAD_GLOBAL             11 (NULL + isinstance)
            618 LOAD_FAST               12 (next_instr)
            620 LOAD_GLOBAL             12 (Instr)
            630 CALL                     2
            638 POP_JUMP_IF_FALSE       62 (to 764)

 71         640 LOAD_FAST               12 (next_instr)
            642 LOAD_ATTR               14 (name)
            662 LOAD_CONST               8 (('CALL', 'CALL_METHOD'))
            664 CONTAINS_OP              0
            666 POP_JUMP_IF_FALSE       48 (to 764)

 72         668 LOAD_FAST               12 (next_instr)
            670 LOAD_ATTR               24 (arg)
            690 LOAD_CONST               4 (0)
            692 COMPARE_OP              40 (==)
            696 POP_JUMP_IF_FALSE       33 (to 764)

 75         698 LOAD_FAST               10 (final_instructions)
            700 LOAD_ATTR               17 (NULL|self + append)

 76         720 LOAD_GLOBAL             13 (NULL + Instr)
            730 LOAD_CONST               9 ('JUMP_FORWARD')
            732 LOAD_FAST                8 (breakall_exit_label)
            734 CALL                     2

 75         742 CALL                     1
            750 POP_TOP

 79         752 LOAD_FAST               11 (i)
            754 LOAD_CONST              10 (2)
            756 BINARY_OP               13 (+=)
            760 STORE_FAST              11 (i)

 80         762 JUMP_BACKWARD          171 (to 422)

 82     >>  764 LOAD_FAST               10 (final_instructions)
            766 LOAD_ATTR               17 (NULL|self + append)
            786 LOAD_FAST                6 (instr)
            788 CALL                     1
            796 POP_TOP

 83         798 LOAD_FAST               11 (i)
            800 LOAD_CONST               6 (1)
            802 BINARY_OP               13 (+=)
            806 STORE_FAST              11 (i)

 58         808 LOAD_FAST               11 (i)
            810 LOAD_GLOBAL             23 (NULL + len)
            820 LOAD_FAST                9 (modified_instructions)
            822 CALL                     1
            830 COMPARE_OP               2 (<)
            834 POP_JUMP_IF_FALSE        1 (to 838)
            836 JUMP_BACKWARD          194 (to 450)

 86     >>  838 LOAD_GLOBAL              1 (NULL + Bytecode)
            848 LOAD_FAST               10 (final_instructions)
            850 CALL                     1
            858 STORE_FAST              13 (modified_bc)

 89         860 LOAD_FAST                1 (original_bc)
            862 LOAD_ATTR               26 (argcount)
            882 LOAD_FAST               13 (modified_bc)
            884 STORE_ATTR              13 (argcount)

 90         894 LOAD_FAST                1 (original_bc)
            896 LOAD_ATTR               28 (posonlyargcount)
            916 LOAD_FAST               13 (modified_bc)
            918 STORE_ATTR              14 (posonlyargcount)

 91         928 LOAD_FAST                1 (original_bc)
            930 LOAD_ATTR               30 (kwonlyargcount)
            950 LOAD_FAST               13 (modified_bc)
            952 STORE_ATTR              15 (kwonlyargcount)

 92         962 LOAD_FAST                1 (original_bc)
            964 LOAD_ATTR               32 (first_lineno)
            984 LOAD_FAST               13 (modified_bc)
            986 STORE_ATTR              16 (first_lineno)

 93         996 LOAD_FAST                1 (original_bc)
            998 LOAD_ATTR               34 (filename)
           1018 LOAD_FAST               13 (modified_bc)
           1020 STORE_ATTR              17 (filename)

 94        1030 LOAD_FAST                1 (original_bc)
           1032 LOAD_ATTR               14 (name)
           1052 LOAD_FAST               13 (modified_bc)
           1054 STORE_ATTR               7 (name)

 95        1064 LOAD_FAST                1 (original_bc)
           1066 LOAD_ATTR               36 (flags)
           1086 LOAD_FAST               13 (modified_bc)
           1088 STORE_ATTR              18 (flags)

 98        1098 LOAD_FAST               13 (modified_bc)
           1100 LOAD_ATTR               39 (NULL|self + to_code)
           1120 CALL                     0
           1128 STORE_FAST              14 (new_code)

101        1130 LOAD_GLOBAL             41 (NULL + types)
           1140 LOAD_ATTR               42 (FunctionType)

102        1160 LOAD_FAST               14 (new_code)

103        1162 LOAD_FAST                0 (func)
           1164 LOAD_ATTR               44 (__globals__)

104        1184 LOAD_FAST                0 (func)
           1186 LOAD_ATTR               46 (__name__)

105        1206 LOAD_FAST                0 (func)
           1208 LOAD_ATTR               48 (__defaults__)

106        1228 LOAD_FAST                0 (func)
           1230 LOAD_ATTR               50 (__closure__)

101        1250 KW_NAMES                11 (('name', 'argdefs', 'closure'))
           1252 CALL                     5
           1260 STORE_FAST              15 (new_func)

109        1262 LOAD_FAST               15 (new_func)
           1264 RETURN_VALUE