From 2136d3385a919126abf99901faaea0fade070e42 Mon Sep 17 00:00:00 2001 From: rocky Date: Fri, 19 Dec 2025 15:06:30 -0500 Subject: [PATCH 1/6] Start RustPython codetype and disassembly --- xdis/codetype/code313rust.py | 91 ++++++++++++ xdis/load.py | 1 - xdis/unmarsh_graal.py | 26 ---- xdis/unmarsh_rust.py | 281 +++++++++++++++++++++++++++++++++++ xdis/unmarshal.py | 28 ++-- 5 files changed, 382 insertions(+), 45 deletions(-) create mode 100644 xdis/codetype/code313rust.py create mode 100644 xdis/unmarsh_rust.py diff --git a/xdis/codetype/code313rust.py b/xdis/codetype/code313rust.py new file mode 100644 index 00000000..4749835e --- /dev/null +++ b/xdis/codetype/code313rust.py @@ -0,0 +1,91 @@ +# (C) Copyright 2025 by Rocky Bernstein +# +# This program is free software; you can redistribute it and/or +# modify it under the terms of the GNU General Public License +# as published by the Free Software Foundation; either version 2 +# of the License, or (at your option) any later version. +# +# This program is distributed in the hope that it will be useful, +# but WITHOUT ANY WARRANTY; without even the implied warranty of +# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +# GNU General Public License for more details. +# +# You should have received a copy of the GNU General Public License +# along with this program; if not, write to the Free Software +# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. + +from dataclasses import dataclass +from typing import Any, Dict, Tuple, Union + +from xdis.codetype.base import CodeBase + + +@dataclass +class SourceLocation: + # line: 1-based int + line: int + # character_offset: 1-based int (constructed from a zero-indexed stored value) + character_offset: int + + +class Code313Rust(CodeBase): + """Class for a RustPython 3.13 code object used when a Python + interpreter is not RustPython 3.13 but working on RustPython 3.13 bytecode. It + also functions as an object that can be used to build or write a + Python3 code object, since we allow mutable structures. + + When done mutating, call method to_native(). + + For convenience in generating code objects, fields like + `co_consts`, co_names which are (immutable) tuples in the end-result can be stored + instead as (mutable) lists. Likewise, the line number table `co_lnotab` + can be stored as a simple list of offset, line_number tuples. + + """ + def __init__( + self, + co_argcount: int, + co_posonlyargcount: int, + co_kwonlyargcount: int, + co_nlocals: int, + co_stacksize: int, + co_flags: int, + co_code: bytes, + co_consts: tuple, + co_names: tuple[str], + co_varnames: tuple[str], + co_filename: str, + co_name: str, + co_qualname: str, + co_firstlineno: int, + co_linetable: tuple[SourceLocation], + co_freevars, + co_cellvars, + co_exceptiontable = tuple(), + collection_order: Dict[Union[set, frozenset, dict], Tuple[Any]] = {}, + version_triple: Tuple[int, int, int] = (0, 0, 0), + ) -> None: + self.co_argcount = co_argcount + self.co_posonlyargcount = co_posonlyargcount + self.co_kwonlyargcount = co_kwonlyargcount + self.co_nlocals = co_nlocals + self.co_stacksize = co_stacksize + self.co_flags = co_flags + self.co_code = co_code + self.co_consts = co_consts + self.co_names = co_names + self.co_varnames = co_varnames + self.co_filename = co_filename + self.co_name = co_name + self.co_firstlineno = co_firstlineno # None if 0 in serialized form + self.co_linetable = co_linetable + self.co_qualname = co_qualname + self.co_cellvars = co_cellvars + self.co_linetable = co_linetable + self.co_freevars= co_freevars + self.co_exceptiontable = co_exceptiontable + self.co_collection_order = collection_order + version_triple = version_triple + + def co_lines(self): + return [(sl.line, sl.character_offset, sl.character_offset) for sl in self.co_linetable] diff --git a/xdis/load.py b/xdis/load.py index 30d03eaa..7e88edd9 100644 --- a/xdis/load.py +++ b/xdis/load.py @@ -250,7 +250,6 @@ def load_module_from_file_object( RUSTPYTHON_MAGICS ) + list(JYTHON_MAGICS): version = magicint2version.get(magic_int, "") - raise ImportError(f"Magic int {magic_int} ({version}) is not supported.") if magic_int in INTERIM_MAGIC_INTS: raise ImportError( diff --git a/xdis/unmarsh_graal.py b/xdis/unmarsh_graal.py index 5b39d98d..2f860969 100644 --- a/xdis/unmarsh_graal.py +++ b/xdis/unmarsh_graal.py @@ -29,7 +29,6 @@ from typing import Any, Dict, Tuple, Union from xdis.codetype import to_portable -from xdis.cross_types import LongTypeForPython3 from xdis.magics import GRAAL3_MAGICS, magic_int2tuple from xdis.unmarshal import ( TYPE_ARRAY, @@ -37,7 +36,6 @@ TYPE_ASCII_INTERNED, TYPE_BINARY_COMPLEX, TYPE_BINARY_FLOAT, - TYPE_CODE, TYPE_COMPLEX, TYPE_DICT, TYPE_ELLIPSIS, @@ -69,14 +67,6 @@ ) from xdis.version_info import IS_GRAAL, PYTHON_VERSION_TRIPLE, version_tuple_to_str - -def long(n: int) -> LongTypeForPython3: - return LongTypeForPython3(n) - - # FIXME: we should write a bytes() class with a repr - # that prints the b'' prefix so that Python2 can - # print out Python3 code correctly - # Graal Array types TYPE_CODE_GRAAL = "C" ARRAY_TYPE_BOOLEAN = "B" @@ -138,22 +128,6 @@ def long(n: int) -> LongTypeForPython3: JAVA_MARSHAL_SHIFT = 15 JAVA_MARSHAL_BASE = 1 << JAVA_MARSHAL_SHIFT -def compat_str(s: Union[str, bytes]) -> Union[str, bytes]: - """ - This handles working with strings between Python2 and Python3. - """ - if isinstance(s, bytes): - return s.decode("utf-8", errors="ignore") - elif not isinstance(s, str): - return str(s) - else: - return s - - -def compat_u2s(u) -> str: - return str(u) - - class VersionIndependentUnmarshallerGraal(VersionIndependentUnmarshaller): def __init__(self, fp, magic_int, bytes_for_s, code_objects={}) -> None: """ diff --git a/xdis/unmarsh_rust.py b/xdis/unmarsh_rust.py new file mode 100644 index 00000000..836afb86 --- /dev/null +++ b/xdis/unmarsh_rust.py @@ -0,0 +1,281 @@ +# Copyright (c) 2015-2021, 2024-2025 by Rocky Bernstein +# +# This program is free software; you can redistribute it and/or +# modify it under the terms of the GNU General Public License +# as published by the Free Software Foundation; either version 2 +# of the License, or (at your option) any later version. +# +# This program is distributed in the hope that it will be useful, +# but WITHOUT ANY WARRANTY; without even the implied warranty of +# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +# GNU General Public License for more details. +# +# You should have received a copy of the GNU General Public License +# along with this program; if not, write to the Free Software +# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. + +"""RustPython version-independent Python object deserialization (unmarshal). + +This is needed when the bytecode extracted is from +a different version than the currently-running Python. + +When the running interpreter and the read-in bytecode are the same, +you can use Python's built-in ``marshal.loads()`` to produce a code +object. +""" + +from struct import unpack +from typing import Any, Dict, List, Tuple, Union + +from xdis.codetype.code313rust import Code313Rust, SourceLocation +from xdis.magics import magic_int2tuple +from xdis.unmarshal import ( + TYPE_ASCII, + TYPE_ASCII_INTERNED, + TYPE_BINARY_COMPLEX, + TYPE_BINARY_FLOAT, + TYPE_CODE, + TYPE_DICT, + TYPE_ELLIPSIS, + TYPE_FALSE, + TYPE_FROZENSET, + TYPE_INT, + TYPE_INT64, + TYPE_INTERNED, + TYPE_LIST, + TYPE_LONG, + TYPE_NONE, + TYPE_NULL, + TYPE_REF, + TYPE_SET, + TYPE_SHORT_ASCII, + TYPE_SHORT_ASCII_INTERNED, + TYPE_SLICE, + TYPE_SMALL_TUPLE, + TYPE_STOPITER, + TYPE_STRING, + TYPE_STRINGREF, + TYPE_TRUE, + TYPE_TUPLE, + TYPE_UNICODE, + TYPE_UNKNOWN, + VersionIndependentUnmarshaller, + compat_str, +) +from xdis.version_info import version_tuple_to_str + +# Bit set on marshalType if we should +# add obj to intern_objects. +# FLAG_REF is the marshal.c name +FLAG_REF = 0x80 + +TYPE_COMPLEX_RUSTPYTHON = "y" +TYPE_FLOAT_RUSTPYTHON = "g" + +# The keys in the following dictionary are unmarshal codes, like "s", +# "c", "<", etc. The values of the dictionary are names of routines +# to call that do the data unmarshaling. +# +# Note: we could eliminate the parameters if this were all inside a +# class. This might be good from an efficiency standpoint, and bad +# from a functional-programming standpoint. Pick your poison. +# EDIT: I'm choosing efficiency over functional programming. +UNMARSHAL_DISPATCH_TABLE = { + TYPE_ASCII: "ASCII", + TYPE_ASCII_INTERNED: "ASCII_interned", + TYPE_BINARY_COMPLEX: "binary_complex", + TYPE_BINARY_FLOAT: "binary_float", + TYPE_COMPLEX_RUSTPYTHON: "complex", + TYPE_CODE: "code_rust", + TYPE_DICT: "dict", + TYPE_ELLIPSIS: "Ellipsis", + TYPE_FALSE: "False", + TYPE_FLOAT_RUSTPYTHON: "float", + TYPE_FROZENSET: "frozenset", + TYPE_INT64: "int64", + TYPE_INT: "int32", + TYPE_INTERNED: "interned", + TYPE_LIST: "list", + TYPE_LONG: "long", + TYPE_NONE: "None", + TYPE_NULL: "C_NULL", + TYPE_REF: "object_reference", + TYPE_SET: "set", + TYPE_SHORT_ASCII: "short_ASCII", + TYPE_SHORT_ASCII_INTERNED: "short_ASCII_interned", + TYPE_SLICE: "slice", + TYPE_SMALL_TUPLE: "small_tuple", + TYPE_STOPITER: "stopIteration", + TYPE_STRING: "string", + TYPE_STRINGREF: "python2_string_reference", + TYPE_TRUE: "True", + TYPE_TUPLE: "tuple", + TYPE_UNICODE: "unicode", + TYPE_UNKNOWN: "unknown", +} + +class MarshalError(Exception): + pass + +class VersionIndependentUnmarshallerRust(VersionIndependentUnmarshaller): + def __init__(self, fp, magic_int, bytes_for_s, code_objects={}) -> None: + """ + Marshal versions: + 4: [3.4a3, 3.13) (self.magic_int: 3280 onwards) + 5: [3.14, current) (self.magic_int: circa 3608) + + In Python 3, a ``bytes`` type is used for strings. + """ + self.fp = fp + self.magic_int = magic_int + self.code_objects = code_objects + + # Save a list of offsets in the bytecode file where code + # objects starts. + self.code_to_file_offsets = {} + + # It is helpful to save the order in sets, frozensets and dictionary keys, + # so that on writing a bytecode file we can duplicate this order. + self.collection_order: Dict[Union[set, frozenset, dict], Tuple[Any]] = {} + + self.bytes_for_s = bytes_for_s + self.version_triple = magic_int2tuple(self.magic_int) + if self.version_triple >= (3, 14): + self.marshal_version = 5 + elif (3, 14) > self.version_triple >= (3, 4): + if self.magic_int in (12897,): + self.marshal_version = 3 + else: + self.marshal_version = 4 + else: + assert False, f"version {version_tuple_to_str(self.version.triple)} is not a graal version" + + self.intern_strings = [] + self.intern_objects = [] + self.is_graal = False + self.is_pypy = False + self.is_rust = True + + self.UNMARSHAL_DISPATCH_TABLE = UNMARSHAL_DISPATCH_TABLE + + def t_code_rust(self, save_ref, bytes_for_s: bool = False) -> Code313Rust: + # read instructions + instr_count = self.read_int32() + co_code = self.read_slice(instr_count * 2) + + # read locations + loc_count = self.read_int32() + locations: List[SourceLocation] = [] + for _ in range(loc_count): + line = self.read_int32() + if line == 0: + raise MarshalError("invalid source location") + # OneIndexed::new used in Rust requires line != 0 + char_off_zero_indexed = self.read_int32() + locations.append( + SourceLocation( + line=line, + character_offset=char_off_zero_indexed + 1 # convert from zero-indexed + ) + ) + + flags = self.read_int16() + + posonlyarg_count = self.read_int32() + arg_count = self.read_int32() + kwonlyarg_count = self.read_int32() + + # source_path + src_len = self.t_int32(save_ref, bytes_for_s) + source_path = self.read_string(src_len, False) + + first_line_raw = self.read_int32() + first_line_number = None if first_line_raw == 0 else first_line_raw + + max_stackdepth = self.read_int32() + + obj_name_len = self.read_int32() + obj_name = self.read_string(obj_name_len, False) + + qualname_len = self.read_int32() + co_qualname = self.read_string(qualname_len, False) + + cell2arg = None + if self.magic_int not in (12897,): + cell2arg_len = self.read_int32() + if cell2arg_len != 0: + cell2arg = [] + for _ in range(cell2arg_len): + raw = self.read_int32() + # convert raw (u32) to signed i32 + signed = raw if raw < (1 << 31) else raw - (1 << 32) + cell2arg.append(signed) + + # constants + const_count = self.read_int32() + constants = [] + for _ in range(const_count): + # deserialize_value must exist in your runtime; it is the + # counterpart of the Rust deserialize_value() + constants.append(self.r_object(bytes_for_s=bytes_for_s)) + + def read_names(): + n = self.read_int32() + out = [] + for _ in range(n): + length = self.read_int32() + out.append(self.read_string(length, False)) + return out + + co_names = read_names() + co_varnames = read_names() + co_cellvars = read_names() + co_freevars = read_names() + co_nlocals = 0 + + if self.magic_int not in (12897,): + linetable_len = self.read_int32() + co_linetable = self.read_slice(linetable_len) + + exceptiontable_len = self.read_int32() + co_exceptiontable = self.read_slice(exceptiontable_len) + else: + co_linetable = b'' + co_exceptiontable = b'' + + return Code313Rust( + co_argcount=arg_count, + co_posonlyargcount=posonlyarg_count, + co_kwonlyargcount=kwonlyarg_count, + co_nlocals=co_nlocals, + co_stacksize=max_stackdepth, + co_flags=flags, + co_code=co_code, + co_consts=constants, + co_names=co_names, + co_varnames=co_varnames, + co_filename=source_path, + co_name=obj_name, + co_qualname=co_qualname, + co_firstlineno=first_line_number, + co_linetable=locations, + co_freevars=co_freevars, + co_cellvars=co_cellvars, + co_exceptiontable=co_exceptiontable, + ) + + + def read_int16(self): + return int(unpack(" bytes: + return self.fp.read(n) + + def read_string(self, n: int, bytes_for_s: bool=False) -> Union[bytes, str]: + s = self.read_slice(n) + if not bytes_for_s: + s = compat_str(s) + return s diff --git a/xdis/unmarshal.py b/xdis/unmarshal.py index f1002d95..fc347218 100644 --- a/xdis/unmarshal.py +++ b/xdis/unmarshal.py @@ -35,7 +35,6 @@ from xdis.codetype import to_portable from xdis.cross_types import LongTypeForPython3, UnicodeForPython3 from xdis.magics import GRAAL3_MAGICS, PYPY3_MAGICS, RUSTPYTHON_MAGICS, magic_int2tuple -from xdis.version_info import version_tuple_to_str def long(n: int) -> LongTypeForPython3: @@ -89,18 +88,6 @@ def long(n: int) -> LongTypeForPython3: TYPE_UNICODE = "u" TYPE_UNKNOWN = "?" -# Graal Array types -ARRAY_TYPE_BOOLEAN = "B" -ARRAY_TYPE_BYTE = "b" -ARRAY_TYPE_DOUBLE = "d" -ARRAY_TYPE_INT = "i" -ARRAY_TYPE_LONG = "l" -ARRAY_TYPE_OBJECT = "o" -ARRAY_TYPE_SHORT = "s" -ARRAY_TYPE_SLICE = ":" -ARRAY_TYPE_STRING = "S" - - # The keys in the following dictionary are unmarshal codes, like "s", # "c", "<", etc. The values of the dictionary are names of routines # to call that do the data unmarshaling. @@ -206,11 +193,6 @@ def __init__(self, fp, magic_int, bytes_for_s, code_objects={}) -> None: self.is_pypy = magic_int in PYPY3_MAGICS self.is_rust = magic_int in RUSTPYTHON_MAGICS - if magic_int in RUSTPYTHON_MAGICS: - raise NotImplementedError( - f"RustPython {version_tuple_to_str(self.version_triple)} is not supported yet." - ) - self.UNMARSHAL_DISPATCH_TABLE = UNMARSHAL_DISPATCH_TABLE def load(self): @@ -812,6 +794,11 @@ def load_code(fp, magic_int, bytes_for_s: bool = False, code_objects={}): if magic_int in GRAAL3_MAGICS: from xdis.unmarsh_graal import VersionIndependentUnmarshallerGraal um_gen = VersionIndependentUnmarshallerGraal(fp, magic_int, bytes_for_s, code_objects) + elif magic_int in RUSTPYTHON_MAGICS: + from xdis.unmarsh_rust import VersionIndependentUnmarshallerRust + um_gen = VersionIndependentUnmarshallerRust( + fp, magic_int, bytes_for_s, code_objects + ) else: um_gen = VersionIndependentUnmarshaller( fp, magic_int, bytes_for_s, code_objects=code_objects @@ -829,6 +816,11 @@ def load_code_and_get_file_offsets( um_gen = VersionIndependentUnmarshallerGraal( fp, magic_int, bytes_for_s, code_objects ) + elif magic_int in RUSTPYTHON_MAGICS: + from xdis.unmarsh_rust import VersionIndependentUnmarshallerRust + um_gen = VersionIndependentUnmarshallerRust( + fp, magic_int, bytes_for_s, code_objects + ) else: um_gen = VersionIndependentUnmarshaller( fp, magic_int, bytes_for_s, code_objects=code_objects From 9de4086cfecee78a4c5ee2135867143fcec85535 Mon Sep 17 00:00:00 2001 From: rocky Date: Fri, 19 Dec 2025 20:10:16 -0500 Subject: [PATCH 2/6] First cut at RustPython disassembly --- xdis/codetype/code313rust.py | 6 +- xdis/cross_dis.py | 2 +- xdis/disasm.py | 2 + xdis/load.py | 2 +- xdis/op_imports.py | 2 + xdis/opcodes/base.py | 18 ++ xdis/opcodes/opcode_313rust.py | 521 +++++++++++++++++++++++++++++++++ xdis/unmarsh_rust.py | 4 + 8 files changed, 552 insertions(+), 5 deletions(-) create mode 100644 xdis/opcodes/opcode_313rust.py diff --git a/xdis/codetype/code313rust.py b/xdis/codetype/code313rust.py index 4749835e..47426abe 100644 --- a/xdis/codetype/code313rust.py +++ b/xdis/codetype/code313rust.py @@ -58,9 +58,9 @@ def __init__( co_name: str, co_qualname: str, co_firstlineno: int, - co_linetable: tuple[SourceLocation], - co_freevars, - co_cellvars, + co_linetable: bytes, + co_freevars: tuple, + co_cellvars: tuple, co_exceptiontable = tuple(), collection_order: Dict[Union[set, frozenset, dict], Tuple[Any]] = {}, version_triple: Tuple[int, int, int] = (0, 0, 0), diff --git a/xdis/cross_dis.py b/xdis/cross_dis.py index 57fa8e75..57a57f1c 100644 --- a/xdis/cross_dis.py +++ b/xdis/cross_dis.py @@ -259,7 +259,7 @@ def op_has_argument(opcode: int, opc) -> bool: """ Return True if `opcode` instruction has an operand. """ - return opcode >= opc.HAVE_ARGUMENT + return opcode in opc.hasarg if hasattr(opc, "hasarg") else opcode >= opc.HAVE_ARGUMENT def pretty_flags(flags, python_implementation=PYTHON_IMPLEMENTATION) -> str: diff --git a/xdis/disasm.py b/xdis/disasm.py index 4274df80..1bc7ba62 100644 --- a/xdis/disasm.py +++ b/xdis/disasm.py @@ -68,6 +68,8 @@ def get_opcode( lookup = "3.12.7Graal" else: lookup += "Graal" + elif python_implementation == PythonImplementation.RustPython: + lookup += "Rust" if lookup in op_imports.keys(): if alternate_opmap is not None: # TODO: change bytecode version number comment line to indicate altered diff --git a/xdis/load.py b/xdis/load.py index 7e88edd9..eab9d499 100644 --- a/xdis/load.py +++ b/xdis/load.py @@ -224,7 +224,6 @@ def load_module_from_file_object( timestamp = 0 file_offsets = {} - python_implementation = PythonImplementation.CPython try: magic = fp.read(4) magic_int = magic2int(magic) @@ -354,6 +353,7 @@ def load_module_from_file_object( finally: fp.close() + python_implementation = PythonImplementation.RustPython if magic_int in RUSTPYTHON_MAGICS else PythonImplementation.CPython if is_pypy(magic_int, filename): python_implementation = PythonImplementation.PyPy diff --git a/xdis/op_imports.py b/xdis/op_imports.py index bc1b0337..b30d2041 100644 --- a/xdis/op_imports.py +++ b/xdis/op_imports.py @@ -64,6 +64,7 @@ opcode_312, opcode_312graal, opcode_313, + opcode_313rust, opcode_314, ) from xdis.version_info import PythonImplementation, version_tuple_to_str @@ -187,6 +188,7 @@ "3.12.0rc2": opcode_312, "3.12.0": opcode_312, "3.13.0rc3": opcode_313, + "3.13.0Rust": opcode_313rust, "3.14b3": opcode_314, "3.14.0": opcode_314, "3.14": opcode_314, diff --git a/xdis/opcodes/base.py b/xdis/opcodes/base.py index 787b6a07..b67201eb 100644 --- a/xdis/opcodes/base.py +++ b/xdis/opcodes/base.py @@ -188,11 +188,15 @@ def call_op( Put opcode in the class of instructions that perform calls. """ loc["callop"].add(opcode) + if "hasarg" in loc: + loc["hasarg"].append(opcode) nargs_op(loc, name, opcode, pop, push, fallthrough) def compare_op(loc: dict, name: str, opcode: int, pop: int = 2, push: int = 1) -> None: def_op(loc, name, opcode, pop, push) + if "hasarg" in loc: + loc["hasarg"].append(opcode) loc["hascompare"].append(opcode) loc["binaryop"].add(opcode) @@ -203,6 +207,8 @@ def conditional_op(loc: dict, name: str, opcode: int) -> None: def const_op(loc: dict, name: str, opcode: int, pop: int = 0, push: int = 1) -> None: def_op(loc, name, opcode, pop, push) + if "hasarg" in loc: + loc["hasarg"].append(opcode) loc["hasconst"].append(opcode) loc["nullaryop"].add(opcode) @@ -225,6 +231,8 @@ def def_op( def free_op(loc: dict, name: str, opcode: int, pop: int = 0, push: int = 1) -> None: def_op(loc, name, opcode, pop, push) + if "hasarg" in loc: + loc["hasarg"].append(opcode) loc["hasfree"].append(opcode) @@ -242,6 +250,8 @@ def jabs_op( """ def_op(loc, name, opcode, pop, push, fallthrough=fallthrough) loc["hasjabs"].append(opcode) + if "hasarg" in loc: + loc["hasarg"].append(opcode) if conditional: loc["hascondition"].append(opcode) @@ -252,12 +262,16 @@ def jrel_op(loc, name: str, opcode: int, pop: int=0, push: int=0, conditional=Fa """ def_op(loc, name, opcode, pop, push, fallthrough) loc["hasjrel"].append(opcode) + if "hasarg" in loc: + loc["hasarg"].append(opcode) if conditional: loc["hascondition"].append(opcode) def local_op(loc, name, opcode: int, pop=0, push=1) -> None: def_op(loc, name, opcode, pop, push) + if "hasarg" in loc: + loc["hasarg"].append(opcode) loc["haslocal"].append(opcode) loc["nullaryop"].add(opcode) @@ -268,6 +282,8 @@ def name_op(loc: dict, op_name, opcode: int, pop=-2, push=-2) -> None: """ def_op(loc, op_name, opcode, pop, push) loc["hasname"].append(opcode) + if "hasarg" in loc: + loc["hasarg"].append(opcode) loc["nullaryop"].add(opcode) @@ -278,6 +294,8 @@ def nargs_op( Put opcode in the class of instructions that have a variable number of (or *n*) arguments """ def_op(loc, name, opcode, pop, push, fallthrough=fallthrough) + if "hasarg" in loc: + loc["hasarg"].append(opcode) loc["hasnargs"].append(opcode) diff --git a/xdis/opcodes/opcode_313rust.py b/xdis/opcodes/opcode_313rust.py new file mode 100644 index 00000000..9723f6c3 --- /dev/null +++ b/xdis/opcodes/opcode_313rust.py @@ -0,0 +1,521 @@ +""" +RustPython 3.13 bytecode opcodes + +""" + +#FIXME: this needs a lot of going over. + +from typing import Dict, List, Optional, Tuple + +# import xdis.opcodes.opcode_313 as opcode_313 +from xdis.opcodes.base import ( + VARYING_STACK_INT, + binary_op, + call_op, + compare_op, + const_op, + def_op, + finalize_opcodes, + free_op, + init_opdata, + jrel_op, + local_op, + name_op, + nargs_op, + store_op, + unary_op, + update_pj3, + varargs_op, +) +from xdis.opcodes.format.extended import extended_format_binary_op +from xdis.opcodes.opcode_313 import opcode_arg_fmt313, opcode_extended_fmt313 +from xdis.version_info import PythonImplementation + +version_tuple = (3, 13) +python_implementation = PythonImplementation("RustPython") + +# oppush[op] => number of stack entries pushed +oppush: List[int] = [0] * 256 + +# oppop[op] => number of stack entries popped +oppop: List[int] = [0] * 256 + +# opmap[opcode_name] => opcode_number +opmap: Dict[str, int] = {} + +## pseudo opcodes (used in the compiler) mapped to the values +## they can become in the actual code. +_pseudo_ops = {} + +_nb_ops = [ + ("NB_ADD", "+"), + ("NB_AND", "&"), + ("NB_FLOOR_DIVIDE", "//"), + ("NB_LSHIFT", "<<"), + ("NB_MATRIX_MULTIPLY", "@"), + ("NB_MULTIPLY", "*"), + ("NB_REMAINDER", "%"), + ("NB_OR", "|"), + ("NB_POWER", "**"), + ("NB_RSHIFT", ">>"), + ("NB_SUBTRACT", "-"), + ("NB_TRUE_DIVIDE", "/"), + ("NB_XOR", "^"), + ("NB_INPLACE_ADD", "+="), + ("NB_INPLACE_AND", "&="), + ("NB_INPLACE_FLOOR_DIVIDE", "//="), + ("NB_INPLACE_LSHIFT", "<<="), + ("NB_INPLACE_MATRIX_MULTIPLY", "@="), + ("NB_INPLACE_MULTIPLY", "*="), + ("NB_INPLACE_REMAINDER", "%="), + ("NB_INPLACE_OR", "|="), + ("NB_INPLACE_POWER", "**="), + ("NB_INPLACE_RSHIFT", ">>="), + ("NB_INPLACE_SUBTRACT", "-="), + ("NB_INPLACE_TRUE_DIVIDE", "/="), + ("NB_INPLACE_XOR", "^="), +] + +hasexc = [] + +loc = locals() + +init_opdata(loc, from_mod=None, version_tuple=version_tuple) + +loc["opname"].extend([f"<{i}>" for i in range(256, 267)]) +loc["oppop"].extend([0] * 11) +loc["oppush"].extend([0] * 11) + +hasarg = [] +hasconst = [] +hasname = [] +hasjrel = [] +hasjabs = [] +haslocal = [] +hascompare = [] +hasfree = [] +hasexc = [] + +oplists = [ + loc["hasarg"], + loc["hasconst"], + loc["hasname"], + loc["hasjrel"], + loc["hasjabs"], + loc["haslocal"], + loc["hascompare"], + loc["hasfree"], + loc["hasexc"], +] + +# add new table "hasjump" +loc.update({"hasjump": []}) +loc["hasjrel"] = loc["hasjump"] + +def pseudo_op(name: str, op: int, real_ops: list): + def_op(loc, name, op) + _pseudo_ops[name] = real_ops + # add the pseudo opcode to the lists its targets are in + for oplist in oplists: + res = [opmap[rop] in oplist for rop in real_ops] + if any(res): + # FIXME: for some reason JUMP_FORWARD appears to be + # listed as a free op. It isn't. + # if not all(res): + # breakpoint() + # assert all(res) + oplist.append(op) + + +# See RustPython/compiler/core/src/bytecode.rs Instruction +# fmt: off + +# OP NAME OPCODE POP PUSH +#---------------------------------------------------------- +def_op(loc, "NOP", 0, 0, 0) +name_op(loc, "IMPORT_NAME", 1) +def_op(loc, "IMPORT_NAMELESS", 2, 0, 1) +name_op(loc, "IMPORT_FROM", 3) + +local_op(loc, "LOAD_FAST", 4) +name_op(loc, "LOAD_NAME_ANY", 5) +name_op(loc, "LOAD_GLOBAL", 6) +free_op(loc, "LOAD_DEREF", 7) +def_op(loc, "LOAD_CLASS_DEREF", 8) + +store_op(loc, " STORE_FAST", 9, 1, 0, is_type="local") # Local variable +store_op(loc, "STORE_LOCAL", 10, 4, 0) +name_op(loc, "STORE_GLOBAL", 11) # "" +store_op(loc, "STORE_DEREF", 12, 1, 0, is_type="free") + +local_op(loc, "DELETE_FAST", 13, 0, 0) # Local variable number is in operand +local_op(loc, "DELETE_LOCAL", 14, 0, 0) +name_op(loc, "DELETE_GLOBAL", 15) # "" +free_op(loc, "DELETE_DEREF", 16, 0, 0) + +free_op(loc, "LOAD_CLOSURE", 17) +def_op(loc, "SUBSCRIPT", 18, 0, 0) + +def_op(loc, "STORE_SUBSCR", 19, 0, 0) +def_op(loc, "DELETE_SUBSCR", 20, 0, 0) +name_op(loc, "STORE_ATTR", 21) # Index in name list +name_op(loc, "DELETE_ATTR", 22) # "" + +# Operand is in const list +const_op(loc, "LOAD_CONST", 23, 0, 1) +unary_op(loc, "UNARY_OP", 24, 1, 1) +binary_op(loc, "BINARY_OP", 25, 1, 1) +binary_op(loc, "BINARY_OP_INPLACE", 26, 1, 1) +binary_op(loc, "BINARY_SUBCR", 27, 1, 1) +name_op(loc, "LOAD_ATTR", 28) # Index in name list +compare_op(loc, "TEST_OP", 127, 2, 1) # test operator +compare_op(loc, "COMPARE_OP", 138, 2, 1) # Comparison operator +def_op(loc, "COPY", 29) +def_op(loc, "POP_TOP", 30, 1, 0) +def_op(loc, "SWAP", 31, 1, 1) +def_op(loc, "TO_BOOL", 32, 1, 1) +def_op(loc, "ROT_TWO", 33, 2, 2) +def_op(loc, "ROT_THREE", 34, 3, 3) + +nargs_op(loc, "MAKE_FUNCTION", 42) # Flags +def_op(loc, "SET_FUNCTION_ATTR", 43) +call_op(loc, "CALL_FUNCTION", 44) +call_op(loc, "CALL_FUNCTION_KW", 45) +call_op(loc, "CALL_FUNCTION_EX", 46) # Flags +def_op(loc, "LOAD_METHOD", 47) +call_op(loc, "CALL_METHOD", 48) +call_op(loc, "CALL_METHOD_KW", 49) +call_op(loc, "CALL_METHOD_EX", 50) +jrel_op(loc, "FOR_ITER", 51) +def_op(loc, "RETURN_VALUE", 52) +const_op(loc, "RETURN_CONST", 53) +# This must be kept in sync with deepfreeze.py +# resume, acts like a nop +def_op(loc, "RESUME", 54, 0, 0) +def_op(loc, "YIELD", 55) +# TODO: RUSTPYTHON +# Delete below def_op after updating coroutines.py +def_op(loc, "YIELD_FROM", 56) + + +jrel_op(loc, "PUSH_EXC_INFO", 235, 0, 1) +def_op(loc, "CHECK_EXC_MATCH", 236) +jrel_op(loc, "CHECK_EG_MATCH", 237, 0, 0) + +# FIXME: fill in +def_op(loc, "WITH_EXCEPT_START", 249) +def_op(loc, "GET_AITER", 250) +def_op(loc, "GET_ANEXT", 251) +def_op(loc, "BEFORE_ASYNC_WITH", 252) +def_op(loc, "BEFORE_WITH", 253) +def_op(loc, "END_ASYNC_FOR", 254) +def_op(loc, "CLEANUP_THROW", 255) + +def_op(loc, "GET_ITER", 68) +def_op(loc, "GET_YIELD_FROM_ITER", 69) +def_op(loc, "PRINT_EXPR", 70) +def_op(loc, "LOAD_BUILD_CLASS", 71) + +def_op(loc, "LOAD_ASSERTION_ERROR", 74) +def_op(loc, "RETURN_GENERATOR", 75) + +def_op(loc, "LIST_TO_TUPLE", 82) + +def_op(loc, "IMPORT_STAR", 84) +def_op(loc, "SETUP_ANNOTATIONS", 85) + +def_op(loc, "ASYNC_GEN_WRAP", 87) +def_op(loc, "PREP_RERAISE_STAR", 88) +def_op(loc, "POP_EXCEPT", 89) + +HAVE_ARGUMENT = 90 # real opcodes from here have an argument: + +name_op(loc, "STORE_NAME", 90) # Index in name list +name_op(loc, "DELETE_NAME", 91) # "" +varargs_op(loc, "UNPACK_SEQUENCE", 92, 1, VARYING_STACK_INT) # Number of tuple items +def_op(loc, "UNPACK_EX", 94, VARYING_STACK_INT, VARYING_STACK_INT) + +name_op(loc, "LOAD_NAME", 101) # Index in name list +def_op(loc, "BUILD_TUPLE", 102) # Number of tuple items +def_op(loc, "BUILD_LIST", 103) # Number of list items +def_op(loc, "BUILD_SET", 104) # Number of set items +def_op(loc, "BUILD_MAP", 105) # Number of dict entries +name_op(loc, "IMPORT_FROM", 109) # Index in name list +jrel_op(loc, "JUMP_FORWARD", 110) # Number of words to skip +jrel_op(loc, "JUMP_IF_FALSE_OR_POP", 111) # Number of words to skip +jrel_op(loc, "JUMP_IF_TRUE_OR_POP", 112) # "" +jrel_op(loc, "POP_JUMP_IF_FALSE", 114) +jrel_op(loc, "POP_JUMP_IF_TRUE", 115) +def_op(loc, "IS_OP", 117) +def_op(loc, "CONTAINS_OP", 118) +def_op(loc, "RERAISE", 119, 3, 0) +def_op(loc, "BINARY_OP", 122) +jrel_op(loc, "SEND", 123) # Number of bytes to skip +local_op(loc, "LOAD_FAST", 124, 0, 1) # Local variable number +loc["nullaryloadop"].add(124) +def_op(loc , "LOAD_FAST_CHECK" , 127, 0, 1) +local_op(loc, "LOAD_FAST_CHECK", 127) # Local variable number +jrel_op(loc, "POP_JUMP_IF_NOT_NONE", 128) +jrel_op(loc, "POP_JUMP_IF_NONE", 129) +def_op(loc, "RAISE_VARARGS", 130) # Number of raise arguments (1, 2, or 3) +def_op(loc, "GET_AWAITABLE", 131) +def_op(loc, "BUILD_SLICE", 133) # Number of items +jrel_op(loc, "JUMP_BACKWARD_NO_INTERRUPT", 134) # Number of words to skip (backwards) +free_op(loc, "MAKE_CELL", 135, 0, 0) +free_op(loc, "LOAD_DEREF", 137, 0, 1) +loc["nullaryop"].add(137) +loc["nullaryloadop"].add(137) +jrel_op(loc, "JUMP_BACKWARD", 140) # Number of words to skip (backwards) + +def_op(loc, "EXTENDED_ARG", 144) +EXTENDED_ARG = 144 +def_op(loc, "LIST_APPEND", 145) +def_op(loc, "SET_ADD", 146) +def_op(loc, "MAP_ADD", 147) +free_op(loc, "LOAD_CLASSDEREF", 148) +def_op(loc, "COPY_FREE_VARS", 149) +def_op(loc, "YIELD_VALUE", 150) + + +def_op(loc, "MATCH_CLASS", 152) + +def_op(loc, "FORMAT_VALUE", 155) +def_op(loc, "BUILD_CONST_KEY_MAP", 156) +def_op(loc, "BUILD_STRING", 157) + +def_op(loc, "LIST_EXTEND", 162) +def_op(loc, "SET_UPDATE", 163) +def_op(loc, "DICT_MERGE", 164) +def_op(loc, "DICT_UPDATE", 165) + +const_op(loc, "KW_NAMES", 172) + +MIN_PSEUDO_OPCODE = 256 + +pseudo_op("SETUP_FINALLY", 256, ["NOP"]) +hasexc.append(256) +pseudo_op("SETUP_CLEANUP", 257, ["NOP"]) +hasexc.append(257) +pseudo_op("SETUP_WITH", 258, ["NOP"]) +hasexc.append(258) +pseudo_op("POP_BLOCK", 259, ["NOP"]) + +pseudo_op("JUMP", 260, ["JUMP_FORWARD", "JUMP_BACKWARD"]) +pseudo_op("JUMP_NO_INTERRUPT", 261, ["JUMP_FORWARD", "JUMP_BACKWARD_NO_INTERRUPT"]) + +def_op(loc, "MATCH_SEQUENCE", 32, 0, 1) +def_op(loc, "MATCH_KEYS", 33, 0, 2) + + + +# fmt: on + +MAX_PSEUDO_OPCODE = MIN_PSEUDO_OPCODE + len(_pseudo_ops) - 1 + +# extend opcodes to cover pseudo ops + +opname = [f"<{op!r}>" for op in range(MAX_PSEUDO_OPCODE + 1)] +opname.extend([f"<{i}>" for i in range(256, 267)]) +oppop.extend([0] * 11) +oppush.extend([0] * 11) + +for op, i in opmap.items(): + opname[i] = op + + +_specializations = { + "BINARY_OP": [ + "BINARY_OP_ADAPTIVE", + "BINARY_OP_ADD_FLOAT", + "BINARY_OP_ADD_INT", + "BINARY_OP_ADD_UNICODE", + "BINARY_OP_INPLACE_ADD_UNICODE", + "BINARY_OP_MULTIPLY_FLOAT", + "BINARY_OP_MULTIPLY_INT", + "BINARY_OP_SUBTRACT_FLOAT", + "BINARY_OP_SUBTRACT_INT", + ], + "BINARY_SUBSCR": [ + "BINARY_SUBSCR_ADAPTIVE", + "BINARY_SUBSCR_DICT", + "BINARY_SUBSCR_GETITEM", + "BINARY_SUBSCR_LIST_INT", + "BINARY_SUBSCR_TUPLE_INT", + ], + "CALL": [ + "CALL_ADAPTIVE", + "CALL_PY_EXACT_ARGS", + "CALL_PY_WITH_DEFAULTS", + "CALL_BOUND_METHOD_EXACT_ARGS", + "CALL_BUILTIN_CLASS", + "CALL_BUILTIN_FAST_WITH_KEYWORDS", + "CALL_METHOD_DESCRIPTOR_FAST_WITH_KEYWORDS", + "CALL_NO_KW_BUILTIN_FAST", + "CALL_NO_KW_BUILTIN_O", + "CALL_NO_KW_ISINSTANCE", + "CALL_NO_KW_LEN", + "CALL_NO_KW_LIST_APPEND", + "CALL_NO_KW_METHOD_DESCRIPTOR_FAST", + "CALL_NO_KW_METHOD_DESCRIPTOR_NOARGS", + "CALL_NO_KW_METHOD_DESCRIPTOR_O", + "CALL_NO_KW_STR_1", + "CALL_NO_KW_TUPLE_1", + "CALL_NO_KW_TYPE_1", + ], + "COMPARE_OP": [ + "COMPARE_OP_ADAPTIVE", + "COMPARE_OP_FLOAT_JUMP", + "COMPARE_OP_INT_JUMP", + "COMPARE_OP_STR_JUMP", + ], + "EXTENDED_ARG": [ + "EXTENDED_ARG_QUICK", + ], + "FOR_ITER": [ + "FOR_ITER_ADAPTIVE", + "FOR_ITER_LIST", + "FOR_ITER_RANGE", + ], + "JUMP_BACKWARD": [ + "JUMP_BACKWARD_QUICK", + ], + "LOAD_ATTR": [ + "LOAD_ATTR_ADAPTIVE", + # These potentially push [NULL, bound method] onto the stack. + "LOAD_ATTR_CLASS", + "LOAD_ATTR_GETATTRIBUTE_OVERRIDDEN", + "LOAD_ATTR_INSTANCE_VALUE", + "LOAD_ATTR_MODULE", + "LOAD_ATTR_PROPERTY", + "LOAD_ATTR_SLOT", + "LOAD_ATTR_WITH_HINT", + # These will always push [unbound method, self] onto the stack. + "LOAD_ATTR_METHOD_LAZY_DICT", + "LOAD_ATTR_METHOD_NO_DICT", + "LOAD_ATTR_METHOD_WITH_DICT", + "LOAD_ATTR_METHOD_WITH_VALUES", + ], + "LOAD_CONST": [ + "LOAD_CONST__LOAD_FAST", + ], + "LOAD_FAST": [ + "LOAD_FAST__LOAD_CONST", + "LOAD_FAST__LOAD_FAST", + ], + "LOAD_GLOBAL": [ + "LOAD_GLOBAL_ADAPTIVE", + "LOAD_GLOBAL_BUILTIN", + "LOAD_GLOBAL_MODULE", + ], + "RESUME": [ + "RESUME_QUICK", + ], + "STORE_ATTR": [ + "STORE_ATTR_ADAPTIVE", + "STORE_ATTR_INSTANCE_VALUE", + "STORE_ATTR_SLOT", + "STORE_ATTR_WITH_HINT", + ], + "STORE_FAST": [ + "STORE_FAST__LOAD_FAST", + "STORE_FAST__STORE_FAST", + ], + "STORE_SUBSCR": [ + "STORE_SUBSCR_ADAPTIVE", + "STORE_SUBSCR_DICT", + "STORE_SUBSCR_LIST_INT", + ], + "UNPACK_SEQUENCE": [ + "UNPACK_SEQUENCE_ADAPTIVE", + "UNPACK_SEQUENCE_LIST", + "UNPACK_SEQUENCE_TUPLE", + "UNPACK_SEQUENCE_TWO_TUPLE", + ], +} +_specialized_instructions = [ + opcode for family in _specializations.values() for opcode in family +] +_specialization_stats = [ + "success", + "failure", + "hit", + "deferred", + "miss", + "deopt", +] + +_cache_format = { + "LOAD_GLOBAL": { + "counter": 1, + "index": 1, + "module_keys_version": 2, + "builtin_keys_version": 1, + }, + "BINARY_OP": { + "counter": 1, + }, + "UNPACK_SEQUENCE": { + "counter": 1, + }, + "COMPARE_OP": { + "counter": 1, + "mask": 1, + }, + "BINARY_SUBSCR": { + "counter": 1, + "type_version": 2, + "func_version": 1, + }, + "FOR_ITER": { + "counter": 1, + }, + "LOAD_ATTR": { + "counter": 1, + "version": 2, + "keys_version": 2, + "descr": 4, + }, + "STORE_ATTR": { + "counter": 1, + "version": 2, + "index": 1, + }, + "CALL": { + "counter": 1, + "func_version": 2, + "min_args": 1, + }, + "STORE_SUBSCR": { + "counter": 1, + }, +} + +_inline_cache_entries = [ + sum(_cache_format.get(opname[opcode], {}).values()) for opcode in range(256) +] + + +def extended_format_BINARY_OP(opc, instructions) -> Tuple[str, Optional[int]]: + opname = _nb_ops[instructions[0].argval][1] + if opname == "%": + opname = "%%" + elif opname == "%=": + opname = "%%=" + return extended_format_binary_op(opc, instructions, f"%s {opname} %s") + + +opcode_extended_fmt313rust = {} +opcode_arg_fmt = opcode_arg_fmt13rust = {} + +### update arg formatting +opcode_extended_fmt = opcode_extended_fmt312rust = { + **opcode_extended_fmt313, + **{ + "BINARY_OP": extended_format_BINARY_OP, + }, +} + +from xdis.opcodes.opcode_311 import findlinestarts + +update_pj3(globals(), loc) +finalize_opcodes(loc) diff --git a/xdis/unmarsh_rust.py b/xdis/unmarsh_rust.py index 836afb86..8e4f28ae 100644 --- a/xdis/unmarsh_rust.py +++ b/xdis/unmarsh_rust.py @@ -163,6 +163,10 @@ def t_code_rust(self, save_ref, bytes_for_s: bool = False) -> Code313Rust: instr_count = self.read_int32() co_code = self.read_slice(instr_count * 2) + instructions = [ + int.from_bytes(co_code[i:i+2], "little") for i in range(0, len(co_code), 2) + ] + # read locations loc_count = self.read_int32() locations: List[SourceLocation] = [] From 05f355dced0384c4479217e34e655a5d597deeb8 Mon Sep 17 00:00:00 2001 From: rocky Date: Fri, 19 Dec 2025 20:46:47 -0500 Subject: [PATCH 3/6] tweak graal stuff --- ...0.pyc => 02_while1else.graalpy310.pyc-notyet} | Bin ...yc => 01_comprehension.graalpy311.pyc-notyet} | Bin ...lpy311.pyc => 02_async.graalpy311.pyc-notyet} | Bin ...11.pyc => 02_async_for.graalpy311.pyc-notyet} | Bin ...02_async_for_generator.graalpy311.pyc-notyet} | Bin .../02_build_list_unpack.graalpy311.pyc | Bin 1286 -> 0 bytes .../02_build_map_unpack_with_call.graalpy311.pyc | Bin 329 -> 0 bytes ...1.pyc => 02_call_ex_kw.graalpy311.pyc-notyet} | Bin test/bytecode_graal311/02_complex.graalpy311.pyc | Bin 288 -> 0 bytes .../02_fn_varargs.graalpy311.pyc | Bin 518 -> 0 bytes test/bytecode_graal311/02_genexpr.graalpy311.pyc | Bin 806 -> 0 bytes .../02_if_not_or.graalpy311.pyc | Bin 1498 -> 0 bytes .../02_ifelse_comprehension.graalpy311.pyc | Bin 1315 -> 0 bytes test/bytecode_graal311/02_kwargs.graalpy311.pyc | Bin 998 -> 0 bytes .../02_tryfinally_return.graalpy311.pyc | Bin 545 -> 0 bytes .../02_var_annotate.graalpy311.pyc | Bin 561 -> 0 bytes test/bytecode_graal311/02_while1.graalpy311.pyc | Bin 972 -> 0 bytes .../02_while1_if_while1.graalpy311.pyc | Bin 828 -> 0 bytes .../02_while1else.graalpy311.pyc | Bin 971 -> 0 bytes .../02_while_and.graalpy311.pyc | Bin 434 -> 0 bytes .../03_async_await.graalpy311.pyc | Bin 2818 -> 0 bytes .../03_build_tuple_call.graalpy311.pyc | Bin 597 -> 0 bytes .../03_double_star_unpack.graalpy311.pyc | Bin 866 -> 0 bytes .../03_else_removal.graalpy311.pyc | Bin 570 -> 0 bytes .../03_extendedarg.graalpy311.pyc | Bin 605 -> 0 bytes .../03_fn_defaults.graalpy311.pyc | Bin 1297 -> 0 bytes test/bytecode_graal311/03_ifelse.graalpy311.pyc | Bin 2405 -> 0 bytes .../03_ifelse_chained_for.graalpy311.pyc | Bin 830 -> 0 bytes test/bytecode_graal311/04_withas.graalpy311.pyc | Bin 2063 -> 0 bytes xdis/opcodes/opcode_312.py | 4 ++-- 30 files changed, 2 insertions(+), 2 deletions(-) rename test/bytecode_graal310/{02_while1else.graalpy310.pyc => 02_while1else.graalpy310.pyc-notyet} (100%) rename test/bytecode_graal311/{01_comprehension.graalpy311.pyc => 01_comprehension.graalpy311.pyc-notyet} (100%) rename test/bytecode_graal311/{02_async.graalpy311.pyc => 02_async.graalpy311.pyc-notyet} (100%) rename test/bytecode_graal311/{02_async_for.graalpy311.pyc => 02_async_for.graalpy311.pyc-notyet} (100%) rename test/bytecode_graal311/{02_async_for_generator.graalpy311.pyc => 02_async_for_generator.graalpy311.pyc-notyet} (100%) delete mode 100644 test/bytecode_graal311/02_build_list_unpack.graalpy311.pyc delete mode 100644 test/bytecode_graal311/02_build_map_unpack_with_call.graalpy311.pyc rename test/bytecode_graal311/{02_call_ex_kw.graalpy311.pyc => 02_call_ex_kw.graalpy311.pyc-notyet} (100%) delete mode 100644 test/bytecode_graal311/02_complex.graalpy311.pyc delete mode 100644 test/bytecode_graal311/02_fn_varargs.graalpy311.pyc delete mode 100644 test/bytecode_graal311/02_genexpr.graalpy311.pyc delete mode 100644 test/bytecode_graal311/02_if_not_or.graalpy311.pyc delete mode 100644 test/bytecode_graal311/02_ifelse_comprehension.graalpy311.pyc delete mode 100644 test/bytecode_graal311/02_kwargs.graalpy311.pyc delete mode 100644 test/bytecode_graal311/02_tryfinally_return.graalpy311.pyc delete mode 100644 test/bytecode_graal311/02_var_annotate.graalpy311.pyc delete mode 100644 test/bytecode_graal311/02_while1.graalpy311.pyc delete mode 100644 test/bytecode_graal311/02_while1_if_while1.graalpy311.pyc delete mode 100644 test/bytecode_graal311/02_while1else.graalpy311.pyc delete mode 100644 test/bytecode_graal311/02_while_and.graalpy311.pyc delete mode 100644 test/bytecode_graal311/03_async_await.graalpy311.pyc delete mode 100644 test/bytecode_graal311/03_build_tuple_call.graalpy311.pyc delete mode 100644 test/bytecode_graal311/03_double_star_unpack.graalpy311.pyc delete mode 100644 test/bytecode_graal311/03_else_removal.graalpy311.pyc delete mode 100644 test/bytecode_graal311/03_extendedarg.graalpy311.pyc delete mode 100644 test/bytecode_graal311/03_fn_defaults.graalpy311.pyc delete mode 100644 test/bytecode_graal311/03_ifelse.graalpy311.pyc delete mode 100644 test/bytecode_graal311/03_ifelse_chained_for.graalpy311.pyc delete mode 100644 test/bytecode_graal311/04_withas.graalpy311.pyc diff --git a/test/bytecode_graal310/02_while1else.graalpy310.pyc b/test/bytecode_graal310/02_while1else.graalpy310.pyc-notyet similarity index 100% rename from test/bytecode_graal310/02_while1else.graalpy310.pyc rename to test/bytecode_graal310/02_while1else.graalpy310.pyc-notyet diff --git a/test/bytecode_graal311/01_comprehension.graalpy311.pyc b/test/bytecode_graal311/01_comprehension.graalpy311.pyc-notyet similarity index 100% rename from test/bytecode_graal311/01_comprehension.graalpy311.pyc rename to test/bytecode_graal311/01_comprehension.graalpy311.pyc-notyet diff --git a/test/bytecode_graal311/02_async.graalpy311.pyc b/test/bytecode_graal311/02_async.graalpy311.pyc-notyet similarity index 100% rename from test/bytecode_graal311/02_async.graalpy311.pyc rename to test/bytecode_graal311/02_async.graalpy311.pyc-notyet diff --git a/test/bytecode_graal311/02_async_for.graalpy311.pyc b/test/bytecode_graal311/02_async_for.graalpy311.pyc-notyet similarity index 100% rename from test/bytecode_graal311/02_async_for.graalpy311.pyc rename to test/bytecode_graal311/02_async_for.graalpy311.pyc-notyet diff --git a/test/bytecode_graal311/02_async_for_generator.graalpy311.pyc b/test/bytecode_graal311/02_async_for_generator.graalpy311.pyc-notyet similarity index 100% rename from test/bytecode_graal311/02_async_for_generator.graalpy311.pyc rename to test/bytecode_graal311/02_async_for_generator.graalpy311.pyc-notyet diff --git a/test/bytecode_graal311/02_build_list_unpack.graalpy311.pyc b/test/bytecode_graal311/02_build_list_unpack.graalpy311.pyc deleted file mode 100644 index 6ee5743f0352e2fded002dd29288c3eb1ffc8380..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 1286 zcmb7DOLG!I5T4lwyF5}FcF~kcAf(DmEL;P66HCqAL)MfB4-}70SVLgL?pknM%JPrt zU-0PNqX$h%NQwOoyGSY*ZRnn!Z@PQt>xMmhEyGBnt-To((!-&v~}$<1vY-yW$gxMTLx_Dylq7=hT#ZnfY;NwsjE|2&eBvW>JaG>GUEh zkxyS>$Prj!L;jWoFH+C}w49pFnlK|67v>!`hM`|FkbVIEK}fBY$T{8@wkm9mfNO#l zesz(DLWqI?6PxCj?Unp}K#3q`jkL(lnNEi5_RIV_0a2Dq{5SOj_A)bFMb+$Ft7JPx?v za;|D1CF%A-ev^)(tW1+m>4Fc9Huk=o)6Jx3SbI(%g`q9dr2x1_5Ko0*kR?)FpNPcd zMYq5yri$}q=ol3mg5zwA8?@pQ^!^6*k!Zj;Za@ur$HI~$1PCg6+%6Z{(N2-SF6VC% z5aswhLv%Ab|Ftqi#N#&c%Nvuklp92I@e#`Zo#Zk;9;&z;D*@sr?7?l96#wXd f5;TWpQSyHTfPpv3PEy_#G(Jf0Z)=$qY$tX?IFUn8OuGBB6 zEXl~v)2&F!EY>ecEiTb7&de>yNsTYgFD*(=)lVu-H#XHbFp5tq&CE%O&rK|dFU>1R zOwNuk2bvO}oS2iNS5V0;z`$?-XqPMpkg&fPpv3PEy_#G(Jf0Z)=$qY$tX?IFUn8OuGBB6 zEXl~v)2&F!EY>ecEiTb7&de>yNsTYgFD*(=)i*GTPtFGkROl5{G7B&;YycW5%K;>8 za`RJ4b5iY)*+5}9U<9(*fY_cvguz4zq>6><4R7KAH+7zKa?@1`)Jh=DjF c4#+|*P!5O&Spvcc0OI`z0+0xZ2AK&00PU1Axc~qF diff --git a/test/bytecode_graal311/02_fn_varargs.graalpy311.pyc b/test/bytecode_graal311/02_fn_varargs.graalpy311.pyc deleted file mode 100644 index e8c17fc59c68c5b82388794ca1227ce7163340e0..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 518 zcmZutJ5Iwu5Zw^RSV%|^(E$Z*q_7A~2ONO{(^0G(XJcFVr`>fFcbJ|-q~#iL1vmmX zprC?zhL{BL?3wpG<9TE6z}wtlguA`x=#lv8niAJ4;Bsc9%KT(F4Kxp96O|*b^5C}O zMP;Hq8_veD=0MLJ``mm_FTZ}z)7~6Mf!C9J* z%S2u*Ybv+slG>(lZ)>qM@h)Scsu}$C;B!wy)==iSfL(ar4gp<&qa^d`IeDp#4tG-Fa|~Y_x)A zSeL%%-1lX-A2hwrPVcs5WS~tTO{?8?wK87lJ6hJm#=)W7-B%6W(Y>x;?)Jy$iJr!Y ziaBPt+um*H>gs6B=@f#aEZY^)B2@~rC_LKfA6!X`QYNe`g^p36{8|J@+%OWdiWC`+ z3TzfF(*<3ME0MEk=HyrumN@%3lcBwQiTF30`Q-Iu@B3(+3!tB3Q_68`#wZ0&a2f61 zO|bWZruNa5Za5x{A&Ktu*CH6~_=>8lyot4zZP#;ZuBn#ODy9-Zz#5xHr_1ZY5}TB@ zCh45nEKzglY^hSP(93$WVopp=eB~+sRuUo_JPGntIzR^lQefp>9MNJMsQe`x$pq*{ zaV7RPdx#-|EMScmhC#AoB#O|48%mxZFBLJqy?h)a7cqttQN-I6m<4b+4#ivh3rr4c R|K-7lF#>EciWGcu@jslCd;$Of diff --git a/test/bytecode_graal311/02_if_not_or.graalpy311.pyc b/test/bytecode_graal311/02_if_not_or.graalpy311.pyc deleted file mode 100644 index 53717746943c3cb77a78038b5e75a71d6380135d..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 1498 zcmaJ=T~8B16rI^G3T1(oFTc8LB5E{&HE80C@tuG?z_V%E?N};px9o0}K5qYpKgZv| zzcBH^puu49oUX%Hk&~RAJ9qBAbLY(L^IdmJ0IOe)-`lnjUw1JHk~j?1VXES8t-bmw zOoC=B-RswbI12X%L2r=mMcviIMk@(Ym83z^>h#*Gnne9LR6)JpeEB+fv0iO`sCJ{Y z8pUh9fjK8c9rY^()PK{78vV9`1X7cMP#$yeh9SVrZAh;fxqs z)8x?AmL9pAiBKM`snU+>)K#3!U{+1`YK`c#YE&DoFr6Lqtiy8!EOS)3TIlMG5gN3g zfSxFBJoHV^aKt+YQ@LF*#DU>UPaen#>B~*eljSu;X0!J3(3}^bWoEOJr>{BW1tSC}WQN%rP8f24z-het$$x9yAg$#KpC)|zkRGPNFPukbjr+UoMic(>%IQ_Z0H~bnm zxbjAj1W?}hKK~!3`OdlF zO-l2i4KCg;H%mMMiKigtX3xNd-1&S=bmjt3of+IqtIjt~dmg<0>hnr>d-=mF8R5 cH8^q|!#VVysk_Wy!1?lp!3CYnksA_!0RSD#`v3p{ diff --git a/test/bytecode_graal311/02_ifelse_comprehension.graalpy311.pyc b/test/bytecode_graal311/02_ifelse_comprehension.graalpy311.pyc deleted file mode 100644 index 101654931a291779256a46a4dbfc5828470674e7..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 1315 zcmb7D%}(1u5MHnC{9pxW9HAC9pa}H<5-}tkdPqx4GbnJyLD zlFoH0f4|Lj-j;Q_t>|*^Hp5s5|8+SQ)A6Jw=tTir-0FRr2!X+&9u1%2(no z`Hc88`7?230#TlYmDz_1bF>W=$!yCHWRjK>z&vza8>Sz4$Uu{v0USrJOZ*1q$-2NI zKNtlU5-I%)YB4jnQ_)C8^St_JtD71nC!`WzCamx->q=eTm0v6SQel~`usun8x+j$% zQ#911un_Szb_*h|7w43p3(>DEBZ{?1Q7;K7AJr8J!kLVO*AGN?f7G6o4rZq1C%lpH zChnKS{|!+jX(7Tm1F5(PGCSv09M?J)jyM^6yAQ}nn^|w!uGzQ!-TEwu4Kl*wM}!sj zqP8m4Sf|WbP3jal8>=ss8YjrTTHj=^R(HyKST*fN#OI|bE)leFDaWrCsO*Ij{}C>Q z6&}UKh!^8q8i(agY(s>zf%+CIvIw*L_2D!q*Ac$Cv{c>oo#yk~Sw%?q=9H zj**@4(I<67G#@3 ICMS~bH%x-b=Kufz diff --git a/test/bytecode_graal311/02_kwargs.graalpy311.pyc b/test/bytecode_graal311/02_kwargs.graalpy311.pyc deleted file mode 100644 index f533139d614b528ea69ae38a4af6bcd173e89dd1..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 998 zcmbVK&2G~`5T3OinzkyclBg$=q8=iF5{w`M4v0(DYlZ5g50T?+ey9^~y*5p_B@e(m zz$5SkP@bVj1UIBg93ufjD)Ys5C{hoISh(11N!`6{+ z%SkMwu@^L7`r7Uf<3ZA~qtHK|+G-jP!f|ub9cnw4I=1z2qypL2VG{Y$?j-$(kL>#o z+Q+9})Ytda)Z8XIF^Q^04*ql$c9TFpyQ(9DoGe!A%tu5OQdAXpL`9Uvj^VtI$Tb4j zblx5uS+p-IW~=lV*XCv&JTKCAx@KaX%G9`Je%~xxKQ}%%s4=5iaegV5l2!hY6&~Zn zh;v?N(M!gD9EO305kyJb_xyomKWh8oNDaA2<;Ca=Lw`|$t@COYDia8v6Z9v{HQJ$? za6Tw-VFLsGn4%GqO6u$~z z>fF3~2Akqy?=~NN-J@(FGoCVSF)J_95_OH_I7WV8ErT8$@Gp>ut;4(`+&^60;60Km zjN%1=UKp+%STQmKEx{mB_Wx4eLd3Xaf(`k}LBz!xZzFG_hp*%U&&5+EyXV#G26i2W z@^XTXVhXJi{>-_-&E^FNlppi>Qy|>|A6^AE*#HRHWX|pbTIxt1MlP4mILs(-9tMOw Q(7=Bucq1}ytX^RKH_!#CD*ylh diff --git a/test/bytecode_graal311/02_tryfinally_return.graalpy311.pyc b/test/bytecode_graal311/02_tryfinally_return.graalpy311.pyc deleted file mode 100644 index 6a39cc5605de19d176f0bb4e65a87d7c04b089b2..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 545 zcmZus!A^rf5FJXX#8jfhYh&Wkq^?oo$@Bwy@Sw*=iKW|?NCB5c;aL8}Z}H~6e`BKa z8fZx4BX5V9H~VJx;_>K^7@P0Wx#wJ5cPrCb_l+NeEV8PO-J`t^jsV7h1(F6R+#|vBkl-mGfLgyMGyuy0J*LCN lV%vuyHrO^p!E7YpFQaimgoYZ29roRuP3i`u%@xGP?hm&jP7VM7 diff --git a/test/bytecode_graal311/02_var_annotate.graalpy311.pyc b/test/bytecode_graal311/02_var_annotate.graalpy311.pyc deleted file mode 100644 index 0abeef37cae205de99d3e022624186be14c0002d..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 561 zcmbtQ%}T>S5Z>)3X;YLI6ZO=CM+?KH!;* zUQ4b@GnQ$u7z)iztPR&^tRkm+?4x}~Lvz1-n^Xm`n#BX@i za~dF9?$yB~);iv{g=5igI%n3pPQd0a{i2Mmn*?lbQ=6`w6DEk$b#%iXagIO63IZyqy;h9EG=ZJg8=VmxQQb zdTw-v%aMB#WcymU#du4KyeV+E&_G5~{RE&a6(ufx1fwkL_G?oHE|r;X*EI!d>lNks z3%Mv48JAya8gQmTT{EEejLRH!UeB4pfy>5yoH~@CYH@b7PMM|J35Q&Wt0boMcW9Q9 ztU6W_OHrjO-D0B*Jj^ME{Kx#Blqv z94e~%h%9cy8&R`IBbxjc$oQr)#S}J*beus=H&0i)c-`qdrU@(4aPz%3pRmB1>l?LL zlxFBK0F(c#Q7&DPc0rnUR+#BEjC(V^gYoH1Q?7!f`UB)X@(@Y&6=Zd$Ut;_))5jPm o2wICdo%n!Fh1ARi&UE&3c5K*O|zBDEy^14Z(Q?EnA( diff --git a/test/bytecode_graal311/02_while1_if_while1.graalpy311.pyc b/test/bytecode_graal311/02_while1_if_while1.graalpy311.pyc deleted file mode 100644 index 0002ff639756da27eeec120d9bab80cf4521dbdb..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 828 zcmaJfgc5S_JC+p0qdE~rYNfdlOUskqSGXgE~jlA;{i8y72eHjUN9HftN2qy4`) z!C&Z4=(V><5UDEjtQv(%@T}Q+GkH57j$fTTSSLpQ?8jtZ5Pko|ftx7bl^3a0;c&Y9 z#ZTO`Af05Vu8REgxf{>ZNfhp0jDo~XWs zw06ZO*s5V{ohxEe&l~evo>ymnoP}vHlOL3dl#Sowp-Lnl!x=|^0n025K9o!|6<%)L z)87jruYk@k**fAgnaz*fxI>%N6Nh5Z)WAhgI~32w(TlFL&ANPD=haQxtP8R&?WcX6 zw|ITBP5qa>)ael(6h)IYHb3G$YD~sKI6{&?1WKTg;fT*aKx(i+xPasx7=XKYA3%ex z#fFLX@~tuX56Vq%p+*%%WrqDNqnZZoI(IpCCGc-l+NvwQ7icT2@+$W)kGoYrXiyXP Mu^DDzSNf{vZ(7xb00000 diff --git a/test/bytecode_graal311/02_while1else.graalpy311.pyc b/test/bytecode_graal311/02_while1else.graalpy311.pyc deleted file mode 100644 index 891e7d4e942ef319c5da40daab65deb593276270..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 971 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 diff --git a/test/bytecode_graal311/03_double_star_unpack.graalpy311.pyc b/test/bytecode_graal311/03_double_star_unpack.graalpy311.pyc deleted file mode 100644 index 8ed9986bd76aad7ca254a7db87326fe9bb5f4d6c..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 866 zcmcgq%TC)+5S{CL6VfJ89==k%AsPiqHyWYyG{_ zLR(sDWs@yF9@}E;c!Qq&KiX=Yz<<)VY@I$=vq*i6u~Uby16j=%gk-y_d@Ga6&-^LL zocdKOsp}fC{gw_($5xjPu^m_>mAKOdb)zflyXLJmmnm+)trpeKDzRmO1_v5-^|e84 zIF=lbm&`aF;>F#l7xNb(7q<>>9`i5oIntNK$DX;?tO)rEvq?>{KuwD&7pPw2(6lIc z(_BH^yeNt5@~uWYfYJYqh3q1i0fEg-;E5&xui!8-v^ZxhQF6~f3O;rN0epY>c_wnD oM~z<-IrL@y=Y3RSgRGm~8BhU~nGGiXoc{+*!=9LkCpH8g0C;AAS^xk5 diff --git a/test/bytecode_graal311/03_else_removal.graalpy311.pyc b/test/bytecode_graal311/03_else_removal.graalpy311.pyc deleted file mode 100644 index 071201a55019e5d0db44318e0a1ee44e28fb3127..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 570 zcmZWl%TB^T6rE{#`5@84!Wc1e!@>l|1QIvu2e4oPiQ5Ls1RDFwbV^{^{+J8>1wX^3 z3m2x|1C*eiHwhBl3YbO4IKj1GI z4qntZ#v+%1~Q-tb2n?Mj-Yq?Hr3?p-5;Fdbz>sblwU zDwAnCidAdkg+``iQfb0*64AiKnRZDIv!K&Hl82oES}2b^M+fa>YSn~zDGAXm^N5pi z>}3(1E^D?ISYx%z)e~Jt)PL%gdMo|>+FEUhZv7a$*0w!s*j0PBW7q8bUF233m9HF> ze^!MH#szr3u({%d6w@!jpW}d@W4xv`)9OoJT%9?Fo|{Fo;Ps_Ef)>}Fs3VZN`5vnUFywNv kVu9`e&R4l`69$&wfb+qC1ulH>-!y*3|G;k10gTH4pO}Yl3;+NC diff --git a/test/bytecode_graal311/03_fn_defaults.graalpy311.pyc b/test/bytecode_graal311/03_fn_defaults.graalpy311.pyc deleted file mode 100644 index 4643a05bdd6c4f5e654b91ad40c1e7a418293c98..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 1297 zcmb_c&2G~`5T3P78bX08vQ#d80i?3Dv3f$h0UQ!>ww!p=T6JQ_KPBlcJOEcDUWF6w zof{9p331`h3FeD;9S0u}h)>>pGv3+RZ)YcdJi6Z_#)q4?)Axet_7yua&n8kW3zf}- z`1op)%k!wXD918OCYLLju8NCfe!L8$Tox)XWFF1ZSowKUW)mgH<@w-DJ{|bexgV-& zP{u|6Bwg7DMDHA;qb~38Y?g#&te!V*$S|TsSXs#RHSRfxmbs)DyDm;76! zB@Q(JaL9%@y(tK)4A<&RnFl%$DYokD|D~?8$xF1y{1@sx(*)*pJL;UaI>g~5t=eH? zQU0NZ_~!sWX)IbH_1jkPdf+w(u&wPKP?C+6aTqtqn6|Mw(f$jMbHj ybKK^lj8wr~qjmQW^wdLUe0i#lG!jfl!iQ`fyrC+R$gITo;opJPW(P2Y0>1#}9=`Vg diff --git a/test/bytecode_graal311/03_ifelse.graalpy311.pyc b/test/bytecode_graal311/03_ifelse.graalpy311.pyc deleted file mode 100644 index 313272cdadf5f3ff2b9feea6aaa4c149b3e3acb9..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 2405 zcma)8OK;mo5T513dRdN5Nsi-Gbd#b*Ti2FdyEjLNx;@AVlvFtv1Wm1M)e@<6@o|e){40w-4u-KH^C& z@SU1G4W;key^W_%P&?{|$HT*#?>Q%DwZU0|`!tsSe|k-b1}4$jm?qCc}lRYuzDd+lLQ)@ONmkb+=ljj=^krh$0;V@rs#Xem@y zS}K**mPTc5*Qi53*0+K2{FZngYekx1T%cHO0OJggE5JBU@mysV;g!yZXpDWk>z0`g zY(J1z-}X;r+X|!;c0D)4a?7&awq-3PY}XA!+jXRKES(d}%0U=}{vho3CG*z+2F|Og ziCLPesmy%AXwris#wV1$Co;umNg-1)g{dynve;MXpu|&kSy{dk?Hc!ZW2|H}x|!2- z@lU3pzFc?_tJ_hQr>aVMT6(og{EHQqsFb5cBa!~{2_-*R2Xg5t2;1H;1a~;>bfgd8 zS=M#oHqiEu0+gqNNoVLf*cqG!JWfGjuK5yL8>uYajyaOG&4`Foz!pMk-vw|O00*FR zVF|5tW5RO|X~Y0M(DUls>iRZ$YJm?(qQ1@4RGZ60PsEyLj;o@5q-6I64f4iaUXC(z zm$7mynisD{lvUJBR;c1qdsVz#qNS*yT;z}`0CI|WJ1!jWqPKke`?ek0$h$8Go*!c6 zJH{zM&`f98&7GS7LO{T9ah$-^PO_X1Fv>7W^spZX0+2ZHu#IFv5#d9IwQ&MxF2D>s zYYBTkU|c0`SY=AO2CU#HoveH^lp4k5sPL5;!vG;sI*`ubxqw-*m zUr*7T)5tY;4HPiSWcZ4%MDr>wX0tD%m8hg&%yYOb7y~H!I~X2@X9J0DVbuEge@*4^*^Ox`a$Mwt+<{I9+I@4^_?#7^O5u-K=Wn83(Q&xQneC7)Dc2(Kx$nn6}x3f(Qz485Qr4fC7&jUA2d{lXg0={%$wrMLcc(RiEkYtj1hc<5FtT` zm^Z-0kT0Wz)&Kkn*y>{fmr@-`hqcYbkyKl;ybE}Z@)G~#|236DqqNy@fG2uDGr&V8 zbeH+K)Q>nHm->kFvr?aM?w9(M^M(Ou^o^b1i`qWZV8R#vsN-~l>O1f84E*ua)qr8O I1Q|BKAHn%|n*aa+ diff --git a/test/bytecode_graal311/04_withas.graalpy311.pyc b/test/bytecode_graal311/04_withas.graalpy311.pyc deleted file mode 100644 index 85c8550f020c072e1d01b892041e5aa24f332db2..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 2063 zcmah}O>f&q5Z&d6EPp7G2v&w&SV{{QEdnIWfrlP~9^w{lQ6MPPQ+p9;X-yH4NSRAJ z){#8rH}voHH{@^RR3IqS#(j?z1-Xvhksfz;c6Vm>?d(4OrL`j<2fwz5Z!97H_!%8f zrz1~YWh#w>>66Qm_QEKeT%3AoGJ3V}=8J5S#80lqk@hmBGfzje`BV*ca*>Xdr?Xk6 zy=VULH5LW>>3m_fh4_6-h@&Q)Kc6Mzi>dl%Q)dRXNGP8I10h^7kiwM%L%7Dk6s|e2 zglqZE*PL4z`$S=j!t4^o7QQW_)LdvTHEVAZ%*Dp?7I2oNvmkq|)T?o@APrT{KOKP0Rg*Y{_2XHZ^EEcr1?E_5gKT=KQz%_(DdL`(Pwzo$&$-dcR=vo?3 z9s@lDJCrYED0;GIoQR%zB2J9(d!ujl?Q?l9wi*JYfR-OH8?=aHr}OT3Sr{k{qno!H zTT+-d@Mn9OcMlp;nlf)oTP_;{zv8-?cSYU>i>oDE#(bGSHydcJ(rge!TImk@zo|6& zHoA;7>fyUIO;V;>(@Q-@U8pg)9q@C?&lNulU@bJ1gfqrAKvKU17?(PanV@U79IMBn zt`ES0-UZ0ky<(Qfu$sa|E8)7&0LJYDM*z>N-WC%*0BnFduV{6a_g|I!N9m~+>JI?l zL8Xgx+2@Hmk6_6y98tb4mw8L%t$a`ZErrd3XBYpv!s&sy0@gyqx}=%??g}4}K4+0N z3U|kg$Q&x!^jn&FZRn4raP!nDY&ljDa_e=tWvJJ2Ef4k+peJ^JZ1?3M_U=!9+5sN; z&QlEJE&F|8;5jo~OXe-G;EKEd%$e?qfQQK~mv0m;8L$=_*39q@k{LXY>jGg7P#yt% z;g}|*rlsof%Q)3=T^^i6HaNmK1jj0d?s_iovTr^K^vrpD4y~Si3Et1~4EU3|?R*Y9 z>!dI`J2Kyu|KuH9^0Hb!;9_?Qb65V=tn;sPEpKJOmu{khu}U?=O@laO(jULAoIy8a zi{LhiV}SA%z#Gj(OW~8T!5l*iRv#xYa?KA*g*uOdTyY|U(K!QhoOU#8;n7j*puC#@ NBlYd&G`eF*%D;2GLwf)K diff --git a/xdis/opcodes/opcode_312.py b/xdis/opcodes/opcode_312.py index 0a0e0070..e60f4037 100644 --- a/xdis/opcodes/opcode_312.py +++ b/xdis/opcodes/opcode_312.py @@ -113,9 +113,9 @@ # OP NAME OPCODE POP PUSH def_op(loc , "SETUP_FINALLY" , 256, 0, 1) -def_op(loc , "SETUP_CLEANUP" , 257, 0, 1) +def_op(loc , "SETUP_CLEANUP" , 257, 0, 2) def_op(loc , "SETUP_WITH" , 258, 0, 1) -def_op(loc , "POP_BLOCK" , 259, 0, 1) +def_op(loc , "POP_BLOCK" , 259, 0, 0) jrel_op(loc , "JUMP" , 260, 0, 0) jrel_op(loc , "JUMP_NO_INTERRUPT" , 261, 0, 0) From 8777c18cbcc6c00440ccacc371c3d7d9bde065ad Mon Sep 17 00:00:00 2001 From: rocky Date: Fri, 19 Dec 2025 20:54:13 -0500 Subject: [PATCH 4/6] Graal reduction until we fix better --- .../00_chained-compare.graalpy312.pyc | Bin 456 -> 0 bytes .../01_chained_compare.graalpy312.pyc | Bin 1610 -> 0 bytes .../01_comprehension.graalpy312.pyc | Bin 1253 -> 0 bytes .../01_if_try_except.graalpy312.pyc | Bin 904 -> 0 bytes .../bytecode_graal312/01_try_else.graalpy312.pyc | Bin 856 -> 0 bytes .../01_try_except.graalpy312.pyc | Bin 901 -> 0 bytes test/bytecode_graal312/02_async.graalpy312.pyc | Bin 1282 -> 0 bytes .../02_async_for.graalpy312.pyc | Bin 1059 -> 0 bytes .../02_async_for_generator.graalpy312.pyc | Bin 2019 -> 0 bytes .../02_call_ex_kw.graalpy312.pyc | Bin 2581 -> 0 bytes .../02_try_except_except.graalpy312.pyc | Bin 1055 -> 0 bytes .../02_tryfinally_return.graalpy312.pyc | Bin 546 -> 0 bytes .../02_while1_if_while1.graalpy312.pyc | Bin 829 -> 0 bytes .../02_while1else.graalpy312.pyc | Bin 972 -> 0 bytes .../03_async_await.graalpy312.pyc | Bin 2819 -> 0 bytes .../03_double_star_unpack.graalpy312.pyc | Bin 867 -> 0 bytes .../03_else_removal.graalpy312.pyc | Bin 571 -> 0 bytes .../03_extendedarg.graalpy312.pyc | Bin 606 -> 0 bytes .../03_fn_defaults.graalpy312.pyc | Bin 1298 -> 0 bytes test/bytecode_graal312/03_if_try.graalpy312.pyc | Bin 653 -> 0 bytes test/bytecode_graal312/03_ifelse.graalpy312.pyc | Bin 2406 -> 0 bytes .../03_ifelse_chained_for.graalpy312.pyc | Bin 831 -> 0 bytes .../03_jump_to_jump.graalpy312.pyc | Bin 2413 -> 0 bytes test/bytecode_graal312/03_pop_top.graalpy312.pyc | Bin 960 -> 0 bytes .../03_raise_from.graalpy312.pyc | Bin 533 -> 0 bytes .../03_try_return_except.graalpy312.pyc | Bin 1109 -> 0 bytes .../03_while-if-break.graalpy312.pyc | Bin 681 -> 0 bytes .../03_while_else.graalpy312.pyc | Bin 611 -> 0 bytes test/bytecode_graal312/04_and_del.graalpy312.pyc | Bin 1578 -> 0 bytes .../04_async_stmt.graalpy312.pyc | Bin 684 -> 0 bytes .../04_aug_assign.graalpy312.pyc | Bin 666 -> 0 bytes .../04_for_no_jump_back.graalpy312.pyc | Bin 766 -> 0 bytes test/bytecode_graal312/04_grammar.graalpy312.pyc | Bin 5306 -> 0 bytes .../04_importlist.graalpy312.pyc | Bin 581 -> 0 bytes .../04_lambda_star_default.graalpy312.pyc | Bin 966 -> 0 bytes .../04_try_finally.graalpy312.pyc | Bin 1980 -> 0 bytes test/bytecode_graal312/04_withas.graalpy312.pyc | Bin 2064 -> 0 bytes .../05-for-ifelse.graalpy312.pyc | Bin 748 -> 0 bytes .../bytecode_graal312/05_36lambda.graalpy312.pyc | Bin 2345 -> 0 bytes .../bytecode_graal312/05_abc_test.graalpy312.pyc | Bin 1711 -> 0 bytes .../05_block_fallback.graalpy312.pyc | Bin 1890 -> 0 bytes .../05_empty_ifs.graalpy312.pyc | Bin 367 -> 0 bytes .../05_if_and_comp.graalpy312.pyc | Bin 1500 -> 0 bytes .../bytecode_graal312/05_nonlocal.graalpy312.pyc | Bin 789 -> 0 bytes .../05_return_in_else.graalpy312.pyc | Bin 1134 -> 0 bytes .../05_store_locals.graalpy312.pyc | Bin 839 -> 0 bytes .../05_try_whiletrue.graalpy312.pyc | Bin 771 -> 0 bytes .../05_while_and_if.graalpy312.pyc | Bin 825 -> 0 bytes .../bytecode_graal312/06_listcomp.graalpy312.pyc | Bin 1438 -> 0 bytes .../06_try_return.graalpy312.pyc | Bin 764 -> 0 bytes .../06_while_return.graalpy312.pyc | Bin 1437 -> 0 bytes .../07_build_map_unpack.graalpy312.pyc | Bin 701 -> 0 bytes .../07_forelselast.graalpy312.pyc | Bin 1003 -> 0 bytes test/bytecode_graal312/07_kwargs.graalpy312.pyc | Bin 612 -> 0 bytes .../09_ext_arg_jump.graalpy312.pyc | Bin 1956 -> 0 bytes .../09_while_if_while.graalpy312.pyc | Bin 800 -> 0 bytes test/bytecode_graal312/10_complex.graalpy312.pyc | Bin 3472 -> 0 bytes .../10_extended_arg_loop.graalpy312.pyc | Bin 1979 -> 0 bytes .../10_long_pop_jump.graalpy312.pyc | Bin 2747 -> 0 bytes .../10_while1_popblock.graalpy312.pyc | Bin 1029 -> 0 bytes 60 files changed, 0 insertions(+), 0 deletions(-) delete mode 100644 test/bytecode_graal312/00_chained-compare.graalpy312.pyc delete mode 100644 test/bytecode_graal312/01_chained_compare.graalpy312.pyc delete mode 100644 test/bytecode_graal312/01_comprehension.graalpy312.pyc delete mode 100644 test/bytecode_graal312/01_if_try_except.graalpy312.pyc delete mode 100644 test/bytecode_graal312/01_try_else.graalpy312.pyc delete mode 100644 test/bytecode_graal312/01_try_except.graalpy312.pyc delete mode 100644 test/bytecode_graal312/02_async.graalpy312.pyc delete mode 100644 test/bytecode_graal312/02_async_for.graalpy312.pyc delete mode 100644 test/bytecode_graal312/02_async_for_generator.graalpy312.pyc delete mode 100644 test/bytecode_graal312/02_call_ex_kw.graalpy312.pyc delete mode 100644 test/bytecode_graal312/02_try_except_except.graalpy312.pyc delete mode 100644 test/bytecode_graal312/02_tryfinally_return.graalpy312.pyc delete mode 100644 test/bytecode_graal312/02_while1_if_while1.graalpy312.pyc delete mode 100644 test/bytecode_graal312/02_while1else.graalpy312.pyc delete mode 100644 test/bytecode_graal312/03_async_await.graalpy312.pyc delete mode 100644 test/bytecode_graal312/03_double_star_unpack.graalpy312.pyc delete mode 100644 test/bytecode_graal312/03_else_removal.graalpy312.pyc delete mode 100644 test/bytecode_graal312/03_extendedarg.graalpy312.pyc delete mode 100644 test/bytecode_graal312/03_fn_defaults.graalpy312.pyc delete mode 100644 test/bytecode_graal312/03_if_try.graalpy312.pyc delete mode 100644 test/bytecode_graal312/03_ifelse.graalpy312.pyc delete mode 100644 test/bytecode_graal312/03_ifelse_chained_for.graalpy312.pyc delete mode 100644 test/bytecode_graal312/03_jump_to_jump.graalpy312.pyc delete mode 100644 test/bytecode_graal312/03_pop_top.graalpy312.pyc delete mode 100644 test/bytecode_graal312/03_raise_from.graalpy312.pyc delete mode 100644 test/bytecode_graal312/03_try_return_except.graalpy312.pyc delete mode 100644 test/bytecode_graal312/03_while-if-break.graalpy312.pyc delete mode 100644 test/bytecode_graal312/03_while_else.graalpy312.pyc delete mode 100644 test/bytecode_graal312/04_and_del.graalpy312.pyc delete mode 100644 test/bytecode_graal312/04_async_stmt.graalpy312.pyc delete mode 100644 test/bytecode_graal312/04_aug_assign.graalpy312.pyc delete mode 100644 test/bytecode_graal312/04_for_no_jump_back.graalpy312.pyc delete mode 100644 test/bytecode_graal312/04_grammar.graalpy312.pyc delete mode 100644 test/bytecode_graal312/04_importlist.graalpy312.pyc delete mode 100644 test/bytecode_graal312/04_lambda_star_default.graalpy312.pyc delete mode 100644 test/bytecode_graal312/04_try_finally.graalpy312.pyc delete mode 100644 test/bytecode_graal312/04_withas.graalpy312.pyc delete mode 100644 test/bytecode_graal312/05-for-ifelse.graalpy312.pyc delete mode 100644 test/bytecode_graal312/05_36lambda.graalpy312.pyc delete mode 100644 test/bytecode_graal312/05_abc_test.graalpy312.pyc delete mode 100644 test/bytecode_graal312/05_block_fallback.graalpy312.pyc delete mode 100644 test/bytecode_graal312/05_empty_ifs.graalpy312.pyc delete mode 100644 test/bytecode_graal312/05_if_and_comp.graalpy312.pyc delete mode 100644 test/bytecode_graal312/05_nonlocal.graalpy312.pyc delete mode 100644 test/bytecode_graal312/05_return_in_else.graalpy312.pyc delete mode 100644 test/bytecode_graal312/05_store_locals.graalpy312.pyc delete mode 100644 test/bytecode_graal312/05_try_whiletrue.graalpy312.pyc delete mode 100644 test/bytecode_graal312/05_while_and_if.graalpy312.pyc delete mode 100644 test/bytecode_graal312/06_listcomp.graalpy312.pyc delete mode 100644 test/bytecode_graal312/06_try_return.graalpy312.pyc delete mode 100644 test/bytecode_graal312/06_while_return.graalpy312.pyc delete mode 100644 test/bytecode_graal312/07_build_map_unpack.graalpy312.pyc delete mode 100644 test/bytecode_graal312/07_forelselast.graalpy312.pyc delete mode 100644 test/bytecode_graal312/07_kwargs.graalpy312.pyc delete mode 100644 test/bytecode_graal312/09_ext_arg_jump.graalpy312.pyc delete mode 100644 test/bytecode_graal312/09_while_if_while.graalpy312.pyc delete mode 100644 test/bytecode_graal312/10_complex.graalpy312.pyc delete mode 100644 test/bytecode_graal312/10_extended_arg_loop.graalpy312.pyc delete mode 100644 test/bytecode_graal312/10_long_pop_jump.graalpy312.pyc delete mode 100644 test/bytecode_graal312/10_while1_popblock.graalpy312.pyc diff --git a/test/bytecode_graal312/00_chained-compare.graalpy312.pyc b/test/bytecode_graal312/00_chained-compare.graalpy312.pyc deleted file mode 100644 index 0114fd05a0790cd45316ede02b73c6384307b77d..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 456 zcmbtP%SyvQ6upy#rZyF;$x@+ig*X905Y&aP6cIs$x+>{pXo7i>OtjgVZ`0rKAKa)Q ziryPq(Y5Dr&Kxe>$823L_W*If{unBJAFk1OSqLs?N*1XfySJj`(@2HYgcq5(sd-+j zFiYK85S3iXQt>iM@>q_`tSW@$lWMx-anBoz(2r6XxFSn(zmVH`tq%ZB8Nk&>7uW13 zSy09D@OQ@Y4|Gg>sL`eM^pd+ diff --git a/test/bytecode_graal312/01_chained_compare.graalpy312.pyc b/test/bytecode_graal312/01_chained_compare.graalpy312.pyc deleted file mode 100644 index 0ab104add344872c62da9f3f6c94ceacf19ef583..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 1610 zcmb_cK~K~`6n-=9(z?JdbQ=r=mPJA|M5xAy7m&ncFNzxy(ZtiH+pVy&(6zf2IBEBf z_+z|!^{8i~iN+XW5D?$jZOKA<^qahyH?MEroA=F3=bsE`iSaD^?!`k%^!_UcXX+jkdR2g(T1hYZovDV@_S?|Ai~>E7?xv6lo2E2}IUL?&$r zGR1}@Qx+&t%7QXH>O8LHYX!x=!hRWNO{o{etANUq3Nlb0C^Kbg*ofDaE0C^AUB!fS zGkw~qA-^ax(pR0=Z2k}=P2 zp(akd(hP^PIpt@GqBfTO8f&Ma85YEm&aCMO3?LacX~W>vUUGj9*emgF-l7V|o8;>N zD|i{e5DO~CPSfaNb3YLBEOJh=<13;^UwBNX%SpSQPQ1Y=0nTxeWrB$+i@`^8)3V5F zQR+f7Rn0MQvF8iZ$>! zq-!ygJubl&C~UgB7$Qp1)zLLr&H+OunPJ1Zc!KJ{A_|CsP(Xi;JH$;LBez1LNV3y>;bGph>iiHQ7VYwL#d=VjeD-*1bv*1_yAAm5}6hdJ{ GI^ZA5r~Li^ diff --git a/test/bytecode_graal312/01_comprehension.graalpy312.pyc b/test/bytecode_graal312/01_comprehension.graalpy312.pyc deleted file mode 100644 index 1abc5589eedd649da1c2557075cd256ce93e4d52..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 1253 zcmbVMTWb?R6rS1L+*-UesrF)%EUA}nRA(QW;Tyr-CAIT4;!DlKWYB>h6YE)o+Hn+ zj6*l54n5_Z__{l2J8|Tlo;&?>-HpQPS;tq7mP$Ly@AU&IR5XY^>9hwYJ9Vf2Sa?yd zAIq)`l^=z*{<(RVG2deBbvaK-n!Ttq2;}apOzJ62lGccOtkFu2xV6km{K#M>WAR|0 zFPn|x7EBXsp=y1m5fYf>7OafDlK*Nm``6a@9ILZB5>sB5BMK49_d;OV@jZ>~LcH_o z_~LrIy|W$5A!+A;!(3)*h@~FH;YE2S)QpIzDd2LOc*I%7Twzby;sI+EZPJXa#Au9G z3v7ukC1Whugo$ZoSr(q0m?8RF_7uWG=>-b9p&JY>n`sDv%JmJ*oPxCrO^dAnC2;nQYt#s^qx+m#Hc7#Z+5C`!P2~iqEoA@ulhhP)O1T2vc#6v+?$oOKg zPtz3G1JF0@}FQY5Vt@o(@~zyKYE5oRO?egh!n!chPK diff --git a/test/bytecode_graal312/01_if_try_except.graalpy312.pyc b/test/bytecode_graal312/01_if_try_except.graalpy312.pyc deleted file mode 100644 index 138c9f5eb6bb6bc136fb5724805404990d2fac4d..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 904 zcmZ`%O>5gg5FN>qtvGV6B*urdv3+O=4Na9`8t4Z(6nbb0ZJ;fsrzMs*j;L)JNfy>| z_1F3v`cDca(9q6v*G2^L#Pht_eLFiE`S4StPK@_Ey>Dj*(T}g3_(>f2a*@h-dO1GI zg2W$%>Ggcz$5HS-_h)%}9ZioG!!YqvnWTOaPG(~%l4u?W(jUx6{l0&EBEldk$andJ+xiV|iBA=wt;aHTlc+2e2w%{tN=D5}`@3z=%E2pTpm1q1h$R=AgYd6XxR9SS0R5NfpNb3_%@EC z7_$H;%r&s^0U3skzXjrQ@Eo_8k2GQIFdu7jpnc{OP3%{hXaGPBmx<{yP>O*T??SIF zgVqnVe{DzgWht8@66~NnG}`WIjTR5IMte`SKIGWf`h??it+Dn>>lYmVGM1OI#$C9h a$3#ukf)^eRYutTh%)A7ot0Rc3^8Wzu(t;)c diff --git a/test/bytecode_graal312/01_try_else.graalpy312.pyc b/test/bytecode_graal312/01_try_else.graalpy312.pyc deleted file mode 100644 index d7b5e331fa734582c6dbb04cf5ff96751f0527b0..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 856 zcmah{U2D@&7=BNhHl?-chtthU+A`RUvSn4+l_-e4vh%_zC=5zJ4qGv8Le5EPE)(#V z`5V0S!k-|xL2;n(1I^aKz$ZL8?|I+noV*`-a#AS~7yLcxA(kpRXBF#Qp<2Y z^!68H<(^ITc{FlEfBYqOgIJ&Y^Zn&ys$4CVcGYwicygfpC>%?76rDZqx`*9?4&#CJ zlspLHT#e|bLG;ln^8GJn{v`6`%S{_eWMCoj0s26+Mfd5o*z1WcanyJSL0V~mX|+_a zYO9?~i*{)j_v2K7iIk?=Vk?v?^0Z>>79jlY+(>UMv7yVe{ffB|ZSkqoHd<7E+imCa zO={(O?CWojnqpXIMa$SWBJoDhxNlFeX<^ehj@_2g_{@UTEQ%|U*v6%m)bhX6ffgc5FI;q;-(HUZInZyNe)yM6~$B$mH1E(NE|>FR00m1R*kcy7D*i0juju* ze~sV3KS4s3s9>JiL{_Cf>t){TzMUP9bM&dzB*y#Q!Phf`=*MSH{3H&1xk_a`znmUt zLE=xs^lCZs<0$x^`-?oiisr|wahUk2Oj17yXN##6Nwkau>5rC^;n06}BGNb)auvu$ z`gD=kJR-M7^kv`S8(z<%@p3B9sv2#q!JSZp$=!75bcfFp75CgKQ4qFWrkKc7Bzcm` znaE_EgwY%)s(|(9{vGB!maFHvb$Y|xqtizJ;w6!t*?l^1kM@kqEtAvW{9tTnO~S6sD|TOzr34byQ`d{*;StL#~_<*)oxrXkCdlei^``k z-J;f29g_`psu$*eWpS?B#+LQFMXejPHWcQzaqXa4?ujs7A-;wDaRkQs?&I4yj$+IL zoG~}R!Utp+HvSWc<={EqXFk+~vB!L*$$<`-k2SGhXQBZBHC!g9$3Q6tTD%RtRtBvf zX#d8J>SZaLBNFVOJT%%KXpI&RwMKhSv_9fE)cS#AsC667_3}?muA_zcdT04rR~TTJE9tR9p4g0y>q*rGEQD&EzYP!Fq{fLxBVydbBlJqN0*+`z5>d&dPKnoWubnS`cxlE>1On)s=>CfiH zRwS!wN`K_dpmof?D%_ysi>faI&p8#18TJKy4U&oDs16SIeBbj^tnx8aAe<(2+iiM* z#)?yGH2mt&Otaano!Cwf5yKBGN03>2b(WuIv3)FD(QW%XciFgh%H?gxvuaMTQy#^Q z9~|=BU>0a!)1@cWY>_!#$t|*rxK&;GwlZLuJR9&cuna7(p?%S{_&oyh|6Jym*>OUf zFZ?P8h&JwAu(kUB!zhpy)Lx3^ZY(cn%El#7XD~n@W`^XKp1~lI>>`XCBbCrZ4il?Xoz4;Of)9AL?b8T$)k7y6K@1+fhtnc79&USbNmeb1wX`- zi5GpZrHv9j;Dfg_`(|gSGrM11G6WcHzI5JUpQ~7u=bFlT@GZC3=oaryPql5oGiWN; zF>i;eKlD3JulR6nd&;*wUwQUjziZV!XW*KaY7W{*$EtK#Z+OF=S#LS+L4TOciaaGn zF7pd0aB}Bd54zUrcOP;L4PF|oiL6OYlQpfpl4Eq7NR#7~jOQ}n$@>#Hz|02fNXv1s z{s7~z`QSvba36swtWeN0`f}MeTAhl1qgPT}GFQo-CvVFuB}7N7+S@2CfBy|_w4h7; zdz@S!eOZ%r&50No3K#U)ZVFrk*FmPxr%rNDi$3Ex+@N7vHo$l=CJMhIY?)_1fp8bz z!F#E_=6MsQH!=Lc2$afTL8gYJg+uyF&&e(xuz}231~}7ML;o-Yzeg0|C+pyu)3ewj z_g7qOFb0KS@*8kwoqPc~+n@qjg8t5g+|%C!qc~id=K}DRG9V}UKZNhb{OA?g3{}1& V>r#h_!8j4srkw`0D33PE`2tN}eop`Z diff --git a/test/bytecode_graal312/02_async_for_generator.graalpy312.pyc b/test/bytecode_graal312/02_async_for_generator.graalpy312.pyc deleted file mode 100644 index d78f8ec6baab09c7d40eecdf21b7f9bd3cf3425a..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 2019 zcmah~%Wl&^6rFM12MuXy8X%?QLE8<8#1%+o6J^;A3JY2U8ydN(^B@mLc2b&U%O|kp zXOQ@Y>{+p3fk0wY3CWz}cw8qf6-2Qan&{I&3OH=z`hVk zu`fkZ?rS2c?IbevIMX(XGhLi!@nf40e_Ut=PBEZkwycWjnBBU?A!pF#f@mu3rrSq% zLg+F|PtBWBNlb}`4&#AeMl9_nZlZst#Zq_V_moJTXBm&eIYgI=5>9?GO5Z?JWS&lX zPKld~P%aePcGYaVr9$WtU7q1{Kt|}xJI%#fqpZKv%X3+ok;mG+UavJod9AgRcnlu_ zLetNR{3&($XV#mttdbgp4N=(Us!iaMaL2O%vycYp&OVbyP-nXgC_B3T9FBADCXfRz z$&7!D;V@%)UJmcu0JT+sMdCrmR?mYPipsxQh0K)riR1t$Q(-$wa|+5MXndz&1{X*I z!C}WE8BeTZ{4|zK$RA1gOg-o8AA%4JM|1++Zx|PKz^}2$qO97TUg<70(1;X3Xo_;u z;l{P!GKEI{7Z2w9Ascresd_SA{f&IGUqSzm-o4hd4!Vm!F3#P_F>i%?-Z@^2`0Nic-! zk4cRKv7Z87iaoh67w(DJ?nF&+kEgK>foEC%@>}*Vp7V#S3$?2r<8eDZv*~cKrYtom zp&Pv}Rm*)0DvJLr8GZ{}088e1HY*>9rODev%V-CisGM?od~x`U=k+!DHNsu(VqJcd zUO29*h$TRxh3)8u{0n4aQ*iNxC%6RgWOD##vCo4csIz6da{zS;=kXR{n+LW43fI3* z0z2L30CHkTo;^*9BW>IUbuLXi8s8WHG5+<#D~NUqsZbOh&iR)x?nP8;D!OmLOKn0$ OV?wT!==Z=Niq2n-?f_K) diff --git a/test/bytecode_graal312/02_call_ex_kw.graalpy312.pyc b/test/bytecode_graal312/02_call_ex_kw.graalpy312.pyc deleted file mode 100644 index 1d390f021a632652686876960b86a69bd25a3221..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 2581 zcmd5;%WoS+7@ygPAG=P{+S{ZovW24L5L&Z&DF>)nB{YIlg;XPjBH=pDHgV&Zc0EnP ziM99xIB?{E_)B<5AdVa&PC?>8B@iHxYD6HSe7}iz?K~P#PyDj;J!WQSzTeEZpY#0f z5rYvPUUlDoC(YRBC32j=uR7jt$Mc(&dhtOua5ih5EwS$St?Krk)86ZBwVK7tDdtiHW!wh+4*v{Qm>c2-SYO%3++Ai5@R3I25;n3w8M=?YeUq% zmxpbH5g|*)2h=DUie#brvqt(@p2O&c6-qMgBK8 zl)tpELYswlhCd4JEdM36pXJ|&_6+|fv>pC+Xurt62<^~Rx{qmAm_62H#t$xKl-M8z zg00q0yW&?G0VnUC0x>7$yp#**u0X6qR3SD@Sgm^9t9ELwW`K2?m4>&`5tI-*d9Sx> z%?_rvF}2+aTFv@iIS>uxIP%>le8qu0nl?qUndbiY!r_?rPaF);O3PfqSdv*STBkh%cn zG;^pSoHM{81dKf^)L>l_?k3I@Ro-Z4K|{q&JZ z6uo*bL*?lh#+M128~>T+N)!t;vL6_ub^*=)Jw`kS_b7QDe<1U6p}rXK6g<93_H;a> zyS*S!2bcKDa1>EaqMTm94jae|#@)dgy2Ay@P=5TF1%N#jj((OF_?=G*3Q`oObDW}+ zW7=<%6UGlz+74%Mv=N0tk-;M9t>UEc?LGPaFzpt#7*^l9Lb^x|!JG!xCtwI{;6nEj zWXLi%*8{WlzM4O%VHJpELs9-XVi@j5Fu?Qh(?M=|yUY?g_xU1k5;btXQ)qtH^yR*M0Oz)01*j$}K6k z)|awLQsKD9=nwpXsN|jgJ;J6QgsiPwGAfAs5StL&)MB9H uL}uOW53Q26sr945c0)if*rOYIXej0O|OXJ3PetbTMvkUkXocl2t|&)BvupKTCdai1nUQZ zXF-IX)X``r5lq=OR6z4-Vk;3)SF9`X5uBTYN0@Pe|(e>Y|>wJ8b3ebDZ`Ys(24epKZ zlY0}kH)zqW!9H(L^ZT7=?9*mmZ)?k<=H=0w&82RUZfVOTKHAhAHmR|G&;TpJiydc) z60@U4py0)YKBl3kf+#ducjY)~usl15#!3a$zk!7k7?2=Ye{_BAk2j9lUwwbR)Hi}&7zr>Fq(^w&Z<;@}~SX6+&TGOr8R>)pbChb6XI<{%%BgE;&w UDwOTYN$?9_2l&fc$nx8N00_dO4gdfE diff --git a/test/bytecode_graal312/02_tryfinally_return.graalpy312.pyc b/test/bytecode_graal312/02_tryfinally_return.graalpy312.pyc deleted file mode 100644 index 67de16a1438f3a3359f4245e7ff3cee70a2e375a..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 546 zcmZus!A^rf5FJXX#8jfhYh&Wkq^{9~lj#>2FY2iWBCu_V6v(nvIJTeSuk_}Hc&10B)oc<}1-9c`n~2+Vq_+VTd-9Im_Pj(RU zn8F6HL*vIFi>yu09?;PTM*w5M3P}qTo{`{rNbnR8KyBC%8h~Yh0n=e( lvHimkTkM;mU^Wu)m(jW)LPL$i0mts`CQSp<_6lNa_Xm4M5?ei z+B)@P_asP$>9MOK|I5^!Op{?0Zk_dm*iB@dxN$I^jHDMwsq&?JoSy9MxI53iuft#@ zcfDY6!?q_=y-swl5q(^@xX-I`)K5q9^&-bGC0Ix=*izBmBwC?vQv-J@;D$j5){1y4 z4xIy|@S7cKf670I%6+Zvyybg_nCE6QGp(!KXl6Bz^j3D)y2@6w`cmdp=MM3cYqf&q zI^|m9LFGH2V2g&ib*_j>J#WB!d0v(IyEIIKv3#Rcq-^{)>8V)q(HnF07qHCC;6uqI zRpGbwTl!leM%`C7PCkNS|}Z;Xr9GltkPUgMWFOttKjU}_-h!&;;D$0IL(%= zF41|5=wpAICp@30vpg0r)^)%z#7JnL`6UfMl^2$?cdOaXo;CDOkyg6iW9JvY(7@#m zm0RAK^OIj_>x}8>iCsrgCSJvnNOYU6aW;`ku(Cl6lzt;Dh0bMi-QO(Sw5+vK=sb&Z zYs5)c_7m%!cSJ+~5&H_yT9vKcqGSEB$Sv({w{Y6j#w-xE=LU^`;eJ;9S{xdk#ARf zJ9I!ty!YGofyHt#^p82K+TQIIJI>$I=@q`UDh`YN&dMkLmA3D#y3}nB0z@6=4|$@a zxp*yQDzW36WF{7s1th>#e|4~wo@n8)qQgkRaVgV0gJT*_B#VZCyg4PB+`A1uWQj3Y y3rR%xtGCuGb?vE-aZ{(88zR1bU$jO!w!vLd1j(Wy^M9G~`1Jozh?)+N2HZdSe3$Y7 diff --git a/test/bytecode_graal312/03_async_await.graalpy312.pyc b/test/bytecode_graal312/03_async_await.graalpy312.pyc deleted file mode 100644 index 7765121830f8aff59d2194327a1023ae3767d481..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 2819 zcmb`JO>Y}T7{_PVYsWZsk~%IFhr~${2#|s+MfiXa2cSqGQUP@joGi!LBump>Yu9cP zZo4`0x%dn{az|Vc2M$C?;rY$(Y`t+@wa~xw_ssJ$GtbNJI3GNy*OcJv)y*G%x0L$j zp$MHQ9CqB(u^ak>~M>x|CEM}fb6y6;7uu^Wv$k@t9X?DnHz z5)R$Y-sEuSqt4x({vbN@hyB6Hz#D%!IxDRx^|PGyaJ?!=eDXNhpB%fNPS1(MKtfUP z2zyF3RnJmQt7ogG-7BePspqJs(<`fHxmQumO1JSPs}g$|CXPxaxM z0;_(Zce2pLF2 z_u308G7a6qz8f+-2|am+WRin??jzB6Dkb&S#PGK8-Hax2P6v*VC@8>7fdB=pyA&X@ zH+)^l{>*O+u|HieG`k>(OAhwg5PoKDEji0mooI`?ZSAgpQ+m{G?1)EVuP*!<*VX*L znib!${;^cqe9p6DOmH3%o@PotV7dRRXR<+L4sHm|BfKVaY&=v{8zM8_6dJos6%7NV zjGgSRLHn7Goi4TCEtwJHDjES6fR1w*A%1C60``Q3iv)$P4DB@cH*XvUz#9zKg*=v= zKLhQI#bop>i$iSs%d8>`GA(A&;QEMf&gAg-(*KL!+*g~jeM88}SD>RewMQWOX&=+| UO;NH3{~^9Ga5ft<>eEE`FLV`Q0ssI2 diff --git a/test/bytecode_graal312/03_double_star_unpack.graalpy312.pyc b/test/bytecode_graal312/03_double_star_unpack.graalpy312.pyc deleted file mode 100644 index 756555a0adf4912495c1cf11df4ff75fb0b49189..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 867 zcmcgq%TC)s6usk_gtSSNhewJx#?8gmLC)2==+Dg_k!s34GWXRfe9yR z7?1qH%DW&jy?(lHJ0^~TgQ*!$)BR|)GU@gclZHuZlKyZ!2-`_y;~+F0+gsl-YwPW9 zWIG6_e%!XBu^$|)j;FFpbm0)aS}yRU&0*BFgYfC1k99IAcHS~y5^35J&#bVHm96J5 zlos02QY)8S@%q>md&k>!@Bh(G>jeJ2c4h11|7sqoPcU}o@pUMx`GSya-zs0qr1Eor zMlz><)=KKKMr^;O$I^4vCy&?;9g<4?(gk&;E9$G}tu>b^ZojS;)sHH%Wq}3<8g=!# zL2Nje9FLdG#18S|e%wp=laP;F2e*Lv7x*CQZ27Kdp*1T)zQSx$Q!G)_Vag?{*ElpQ z3f?qV5Lb^%;<9|L(GFnrKVu=g$YnraClh$03BW6OObjh97)zAgFpz?e-9P}}AAX*R pT@=?&V3lS^0=|ZR@6zWFw2Z|J5xC?DMw86ZXB&AsCxNtmNWMHNP!5ICFDGk${RYJnH7qO9ZlnrP`>q? zh#-lkzSo(L?NCHAj6`U=fg{b(kCi3GD4ujL#Cg}0PAE+!U4J%o&VoeWW9)@iJhW=G zCiBd1Pw%^K_}yXU1Q?-_@vX4Q5>{~(69X;^^IbTZqEN+hP`1|+|L zmd^^2l2NR@_g2wZC>jdTz3hPOm<^i5e6Xdlm>K<+hvNe#nDI(laUIn|PZ8F@jzsN0l;jRc{^Bf(;0u=DD7>hs6 Y3CpfLr*MtGTkzojfFuT>0L4(?2et}as{jB1 diff --git a/test/bytecode_graal312/03_extendedarg.graalpy312.pyc b/test/bytecode_graal312/03_extendedarg.graalpy312.pyc deleted file mode 100644 index ab19a59a28ce3fe46978892ea7a6679954929b72..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 606 zcmZ`$O;5r=5M5|hlo$|+2NV8)5mqJPWF+yV7d`k94kiTJp){6l-E9?)^skxt5BvrG z1jE6LI?q@{6JIiYZ)W$+Otw20>uZA1IJxP)GCyAPM;h%&8potnFR0%;MtXicO!`uX z&h11-lXw`a`q=f2jLF2(_@gMGt_c(EknAU3v#~Gtnq9O|F1bDJHKK`C7UCr*#8s`p zGY&_gn*?;UsJT4HGOI0)wrDZ#I#2CfJKsq!t);4HRSs}!ZP?SQU9zW}cG*tfMQW80 zX@0lxlVw#fHsA$>%@IbVn0^8E87}A<#%qcbt-j>x`Ek$Cb1idbyt3ej(c;(^6}VHY zXulOv$VSHe9x%W>@B;$#E6^%)KN$>2`^v+6ka9woHQJEYp*FB7dI)?)kWLU98n~?H pz>u?f#sb{|+%Iup69&?6pz^^$37plzf8F>M{{yF42QZcaJ^`B&Z-W2; diff --git a/test/bytecode_graal312/03_fn_defaults.graalpy312.pyc b/test/bytecode_graal312/03_fn_defaults.graalpy312.pyc deleted file mode 100644 index e429d3a6480d6b669698c4e2b9c7229b0c102487..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 1298 zcmb_c!EVz)5S_J68bX08vQ#ep0i+$<;Fv{s!svArefEqnmyieKSG zd*{Xna6(+TbAoyCuH)bX0`cU{oAJ)hzMY-;>Fb9bVtlxLH-0aO?#|fp@@(YEMIp0k zm>gb>a_>AYF4WM=($VG8n=Olrbb7dm;@m4_UU+#tnI$sFQcSsn3d)uGx0 z@%K0>>!)#=9%(+-+|zt=pXY-&VR9KnamMx*kl^#dZz+zfS`1$R;p9qm5xjaJezf5O zh=V;0vy!gy)&MJC83%0AB6gRDPE)>y^OFG&T&Xe#I@aMlPgJS0nyL_ou~7wYt`_`T zp&<@60C32fIK3$dsti}^OqqK+5Ggk5?Ej^%wa!bl!~7TOPD~S+(`~79n(7dTlQe3F ziMjei4e`$b&~i1EW^+?K_~jLE_2!mi)*v133T@$+dYu-vOtldPn_C-Z#EdkPaFNI> zndG?5xr$}MT%mFIkMz`IW_)_ejx-WXN5Y3}9lWM8lE|#Y_u=1x)n*4UgaW?+Chfnn diff --git a/test/bytecode_graal312/03_if_try.graalpy312.pyc b/test/bytecode_graal312/03_if_try.graalpy312.pyc deleted file mode 100644 index 303f9462d766fadae641b3a77a097feeb0aba810..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 653 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 diff --git a/test/bytecode_graal312/03_while_else.graalpy312.pyc b/test/bytecode_graal312/03_while_else.graalpy312.pyc deleted file mode 100644 index 570bc3c24c2be9edc3185080e7a41879e2cd873c..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 611 zcmYjN!A`D*U+6GU1nF^tCDuIP08ZxfGim2cGfd|5ao`m%@~8oRvVavF>x zUtQ%jUvI%i+F|l*j;L4TUZSK_$rA%J+d#fVo>p+>f%0bqb2f&YL@h&s#R;=X$K-Ro zb&0~3b?xew)tff0n&4vWI#gaIPMw(Xf%B6T>T$KWvZ$HxkOdC=Q?3i6*q78bV iS=(rI{4uZsHDvfu$33SlPy@0j;5T!?F>67_IN%?{0bM}= diff --git a/test/bytecode_graal312/04_and_del.graalpy312.pyc b/test/bytecode_graal312/04_and_del.graalpy312.pyc deleted file mode 100644 index bf313ad0f64d2ed898be3d34660da4b3a0945b29..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 1578 zcma)6%W4x*7(Qoal1V0MOw&ZLmx)U$v{R@TM6sxJA-1vN4G}4AGHr^vkxWaAh$J8) zg1B=bQr!6feFGOhfjch`Ai9utVTqUTn_EX${_ydC|NT$SnKOQEzz~p|#`elPRfxA& zVOX7Z*|IksyWLo-O>C4q*6Ny5U0=4^&GNl1tF`4+n~jOh%38;A?2cn~*6OXAz1V54 zx68J*yuLa;WlbGlTxwJnD|T(NwWVf-*og^oV=RI8XY0+%dd)r;<=i0<36ch`3y~Ms zrO3;ZxnTx-=`7JJh@O&2ufU&74y?j}KQw2spQ(Lmk+ z8=@#pIV?;uEA`C63jt=z#EjI_3n|4ljJb!NPtnsQQ$u(|=-E;}?nXDHt|Ts~v$`1< z3&lj}LzdLVF~x9+Qj~M2y)GKMj2JJ?(W`E66=cCc$VA^Wmx zNKMsZeWRb*?`YAW0QIh5N)zH&n*yK4YwKXL4Y>T zl(Pb%pTc4{iP{&}=W#VsMDB$~!U``QW|55iXP00DH$7VD4f)NDIWD-J8K3hzIqdU1 zH0Lqr2r%yRW6-An)}H{Tfs4L<9(o3t1z1P_WuISyp7%L@w*dCI0bB#_`t}{@+rWx% zSD=@HD!`ufw|w4!egLq~eP9cC;@gj*9|2DR*3tjm=g*+G0oJ_&UIMQH=F$Hf!WeCy zEIH>hhq3o#2k*fFi{1fN4gsbpA;FYa;`p$YqH3zS9NgW(xHy#3c8?Ua&&h5o`6C+? z^Rlt!3Lc&%hgQ|8*Qg!5p~*0U=M+2?&MO5Lv)v~SdKBPMa+#Q`P3-~J; c<67*^7=2Ko@YA6j^}*Zouh19NQL`8257HjZ#{d8T diff --git a/test/bytecode_graal312/04_async_stmt.graalpy312.pyc b/test/bytecode_graal312/04_async_stmt.graalpy312.pyc deleted file mode 100644 index c75dc27f6435e2cc061148194ba19ad3db65b187..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 684 zcmb7B%}&BV5FVf)kQNLYNgDCs#YBT^f^ss(gTxDX@aIfQS!lJiWOu7@v-oKG3O<1^ zVYui_!%q)h{5D_b=i8Z`?jGJ5ML@jnemGxf-|z9mq_7#EC@y@-tQQU&XYAy(Yssl^ccmJs>gC%3XG;(95@~AQS0QOUGAAFt3ayVF7(axL8_f@RxU9SX|t>ul{7HGm~X)!E7Fbc zNQX#|@*2czmM-b@3dHLTd(hGGP|6X(i-FNK_qniCAX*bw>6o|;edUgLONc=O3Upam^2c0CCivpH2YcC3E%of&5y>gNsRvJ2TIj44eJZv?X}Q^}5pL zlToWT=i|B89Suvfwkx>j2#*VQFz!1IF_M#(!)@6qm-+ccqbWO$rVwstcs8D^8GwQU z@Q^pKLuD{(%f55Ht1-NVimHMpV;0;%!D4j=mLi!6@%`EXfT@^l3dSwdp|+<$=-lmV zV1i_EWPj>$*^`5L82q6oOKtCP~y;H2VGjf%e%# f3Fq3nk)UrJp;5m>w3CfKMn2tWibb;!Q!e2by2)lT diff --git a/test/bytecode_graal312/04_for_no_jump_back.graalpy312.pyc b/test/bytecode_graal312/04_for_no_jump_back.graalpy312.pyc deleted file mode 100644 index bd75fa24fa400a0667614e9570cbba37a2baa551..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 766 zcmaJ;O;6iE5Zz7e;5H70B)t?8khmd*t(2@ZR0!>*C`l?@%RPth{4076je3!hRD6aqW&b$2Uhe(N*6aG$ ztLRn$Z(1R1v+CE@Qn}5y=>tZUCH~EAm$n@$8&6w)5-p}-^9otMwa%A;^X=k{;v-P`QDlV@`7D`B zhBp(?9Dnk_3Z5V24pPSM^XnLdzRmQ28Mgkf}{{R30 diff --git a/test/bytecode_graal312/04_grammar.graalpy312.pyc b/test/bytecode_graal312/04_grammar.graalpy312.pyc deleted file mode 100644 index eae6b2b163b5f9935031933219dea29f207a2377..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 5306 zcmdT|TTdHD6h3Pk42IaoHV{l49Q6Wj0EbYKiYDYr)rSPB3T+})DmBa6IPnGf(!%5V zZ}hp3`4#;QytO~UPnD%MYDB+p_JS8X36Mrr&g#sWIWs%+oipdmto_;J3n2kL`T3V0 zehrHJ_6-`@dQHz7`wgR3$(0s<((Bnmv9a6S&ep2>^MmZ(L1VXCS=iqx*0T+x-pJOA z<-L-zRj)Q{x{=*(7M5>huYJB%sO8G#Ty1ghz#kQPkP!JcHH7JJma99>lCjoZCkBT! zR4#!xMG~^9NkWTj>uCBU;fwp$CE;I*UE|=^K$P4HO6$Qja_cJz$*7FB0@Cs&$Swci zkc3|PB`Q&(2;j9CSl>1D=UerIN+Y+wWz=fb8r?u^whoF$X@}SfMrAACtmuBLj?zO^ zAEx?G)?Z7*93qez@IX>7%WdtpZ{05s$F`GNZUkC=C8j_0?^t%4ftEjP4h4sXMyshrpxatcq;%0^+gTl`uz+!;KAd4W2Ar`|dLMW1Qdt_as7=_rpKz-QKM=X7m z`Z4NbEaEH@)`)Ry#Dpa#EpgEjQ2_AKCMq-SWm$Ho!VtBD zA3fvkjAS@OjqM(y&>Ro7(0E?C*q)bp_gz*lx39}}OcIL++tV^l)o42{X{Cy{XJwYE zsrG^_D3zK)FbgAvyZ!piVQ&HK(q+^(4pT}$j{0%-F5WCv^<1gGw&;0*YcQ^p($w<1 zO>Nx=-^ZaahqPhsWl(}4?av4T8P77*oSB>ldx*-7Zp|nf%n!~!X-fz%v6I0}trgT~ zgH9Wh^7PK=N->n*eH3^Wcr>WOCxs4}5cVN!Jc9#DUL&cvGhN~ z(CdGqRvR$cvjMPROvX-U!RvM*jRo0v1^iS)oPfT$r`_#JfWXTTLP9-` z6(`rGQ#Sr6Qg9A(H+_r-;eP@qzU~b{Q?-eib;`5s2iM}Et}q`5j{*(Xhb8QQc9403 z=Pk%*F*A|Rftl1?$t6yBL=7>k24si(vt#7bg}KaXT77G$^R;R@J(rnJFLfB3Zts5j zR?mpD*iP^~@0uDj=jlBJp?%1PtmNrBWHGFVh}n}li%`(qEciW~ulzpY{n^yK*`tu# zmwco*fx0evyxc>s6-3_eeqVx~eb>RxIfiO~I(ff$c!Ib)wlr^V*phdjUA?{4=h?;o z_Nu%A*fjbJ@O#?I_w%W_Y6JfglJ_T9>7ftxQ}Y%q;jXNK&m4+p2`Z)8^{QfyUxH~*j^-`{0Pv@)ERU1i%h)-(m>AFDXRxRim+y#4>0x!A5Wk@`M`FGC? zHa;Zc!K+Yn$5aDt{>EVN@s4Mf^1i39=>IF=Pr+BgwD>;wYw-8rAHfFr8JP1Os=v~l zzoIvrgi;E(6l}x|B8O(zTvI#ea{WJY4?8z$z#*mBwKB3 b2#^{_I=wWU^aM;t(CD`j$2jv)I*$AoLdNpR diff --git a/test/bytecode_graal312/04_importlist.graalpy312.pyc b/test/bytecode_graal312/04_importlist.graalpy312.pyc deleted file mode 100644 index ee3509e31c90c7608d30e473f26f07144692de7b..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 581 zcmbtQOHRWu5Ovzp77zkKKrHA5Xj&ujSs=uY69m>(>Y66PiLKZ{%`zN}4J^4r&jRyW zg|=*YqtUz>kLHc%Jlxx1gzD@we)kyrc%+2eTyQyaGS4D4comjU6Bid_o@?<^a#Olk zXM@=!vD``PxJ^={E$)QxEfJa=T0To4NciRVC;(oo_bwUxJ&h#;ryJih_z^_xMkzs(-IIefsV9%@SoBz<_y((mbTwv2}@g2$4S$Xsv;Tfg^J0;GX{jCVUex1raL&KcN(2 AQvd(} diff --git a/test/bytecode_graal312/04_lambda_star_default.graalpy312.pyc b/test/bytecode_graal312/04_lambda_star_default.graalpy312.pyc deleted file mode 100644 index 41cbce26464dd49175abfab254a354700b73c488..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 966 zcma)4y>8P`6h2O3+R_FQH=+?DVPJ`nnp-IpF+`EDfFTGLf|Lb{#r3a+*v;6xauI5zgf_INUyQyjVy#mLm3Mq3@34Ac<^OOp^U>SM1yy`_^pY zSmRh)(b#eKti+d{a9+Mn^r%eqvboBwdb7Yue79eeF^@utg&Nb4s7^zT%+ka4Cw1+< zaRU)&4gTMjSIq}&pG-0@bQ;hA4Ukr03N8CU&v?xI5_kw&G*y`5NL7Hm!qlRcHZqMh z7SA^HmC8l+M;+M!V$kB)bL13797|fva`0B^d9Jaro+%s58%*esA#D!BZw55*MH6?_ zb39wx!7S`w)=*yo{ZVps+M=hMx3w03Z)o&>sFhy7dsZ{xBi)Mj;|f(K@LeV}%YorjQ*pPsn+2rdA%YK>mfK>kHp60$v>GC=FyVxl mP*sKwf)BPY9%{gXJVX|u9)!WhJ4|@+{{$Q;2PZfR0)GI17L&#R diff --git a/test/bytecode_graal312/04_try_finally.graalpy312.pyc b/test/bytecode_graal312/04_try_finally.graalpy312.pyc deleted file mode 100644 index 885d6ba266d52d970883d2e355e598098e14c028..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 1980 zcmb_c+iuf95MAGh+q6xw0)mPrMJf`lRLo6zK)?f{l@Jj~vt5N}sq9P#+LA7x$n^gPcvG#Oy70((MK#hxLm#-1sv=AI?0 zR>QkPv%+2`ijpXt1)`W2gHFA^Q2Eve2H+du8OBOfXjfCo{av@|tt)P=JkqhPMGlZWq>aVO5N=TYRe+ zh3UEoQ9UK>3HR(RTx;Tz-g*8|b`K_7YT^DXa#XUTl?ik>43V?|pcX1D%D<5M1B3n! zqQLdb>P)d_1bqTMG2tb^aWdO$I&CL%GSgeb4l`XSEZ3goX(Q6flb4a|KPAXy7z3e? zXTqc^z$6*QEGbKF&t`U^^A|+zo~{_PGW^dqo7a4jW$BTwgJQx+!GcteK6v zxn>%nr`E7Jr`9N{8QwdXqY{pnqvbXmotH0<^Cgilza{cAu2ppN`);O;~wPo38Doa+GTCcs{?kgB3w|Ctyuh)&2d2!fqGFOz3c7{CpH zhi?G)0NS2?#`;5NTAJrSG|>xd;nd7+A(}gEd|jZ|cFk_o?KNBV8f)0xRC1(;;a39; z0}P|6;k}2)vsrK*R8~ECdGYT%pO+W@-dN1%HpWXAWD$q&rv1SST=GGRG2tikChMi~ zu~cK?KxPei(Qr*i1IfMV&6y@aDBD4JM3?e3#Cu9?g&Lk~U?{M%1c@K52fPHRBhTKf zPh|2B0Ietg1VHJPJ$dT1p3$+VBn}{NKXo`a{u?oOMRd*4(FI~!`a)d=e+%GvarU1A aI{@vmOi7nQhkJFZ`5i;8_P~`zBmDqs(*Xkj diff --git a/test/bytecode_graal312/04_withas.graalpy312.pyc b/test/bytecode_graal312/04_withas.graalpy312.pyc deleted file mode 100644 index 1a85a7646b3aa1ce856bcd980fd26a2508510021..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 2064 zcmah}U2o$=6rJ%$ntpgUu}rEKHCa#*Xr*2AfFd3cPg@CuKr09j@DjPnG_}?rmB-08 zkMVLVynhj=(|M%6+}4>wBNEE{z(@#BjHK}7$Pk_}GKFW3 zEa6#0_jArIjYFceMQQekatB|Bs5B3nN6k9e29vR|+yO4qEDrM5O1+u}OY%^sJU*Y# zj?v@h#$mDuqHsFS)GX9_7UW@?XfCcsGc{(bJs8F_m7o`2t(mw8BL(vh&yE*`hb8>=`J@A{i-M+RE@(ki+j`6`*D z(=eH>hpUEhzoW*9T!>>62LKmSs%k+?+abWj{v-8N4%|T4qgR3sX?t^Wo9x>?hHj(< zSYJK*P>pKE@Wz(#1O2xp94fTVs5FfMf-GeOsEIo6Cr z-5h`my$6u32gR(8VLgS3*1~lk0E{~TP5_=&vn?ii1lRy|UeWq2AHFINkJ3{k)E@yu z7nLp+a=;UHpTJUBIHF=#t_nvKPH`armcnMivx|RI;q*XU0~?`XQ_{?Se~q_DpR>ps zg}dWLWDd1#`>o8pHuOhQxOwUnwj8Sox$`>QF*NJAmIwPD&=>pPbO!PmdmqN%?g5X6 z?sE(jj{Rq8;5joqOBN1T@WlOp=1liQz{BL0t2c_49M}jA8)kS1$qb&yO@XimC{F;s za7+`@&{FsKWt@7rDG$ye8ysOAf@3v9_dS>Q*|(nrdgeSnhgM&{1n&zx1H*W3yC1^N zIw_6ro-Fp|KSdXpysDPBxY*s&+?Ri~oBW$xt6LfHrMpzYRArjsq9B382&&Y&Bz zMR1$MDM0xI;EiUYmGH^fVveB&tB(^Hx#5SULY+rJt~imw=$rvLPCJ^7@aQN_P+rad Nk>>Vt8r?A@L_vg=nf*u(Mu=GkoUg6I{ZGl`O01kP9j(^w zY?d9p)~#)tj&@FTx#E<1+{4j&Rh=AjTDBTjHG>?3ofp=(xIF5tUvqle(BCtQ$Fu5& zkv6rrw83|Vnc6xTIH_Hxv{}_Z(q?L#E81r@TU0Wmp6RwmC7eGE7Ulx*1_o0}-{r?6 zH^f#0>@pqriG<}M!1pH7WEn=%^=7OTKu9mQ5Q1c2m04$Ef5vaiyz|dx@x_d5g|)0; z#2+kB3DwaOb?jdqf7lKa8*DSTn7d5G;eNqDnLHN~lfsW0@UtiYKag+mH^TQd%sd4W GWq>ctC}sx$ diff --git a/test/bytecode_graal312/05_36lambda.graalpy312.pyc b/test/bytecode_graal312/05_36lambda.graalpy312.pyc deleted file mode 100644 index 3ffa5618faa2d458bcc07ef92bd5c7989249f0fa..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 2345 zcmbVOUvC>l5T8BoUF`g6QYXP7)J|NXl%TX1k>IB&k!W~8hzL2UWQhmMIbWPp&pzw! zoFpc6W-ecWkmmF&%Tt6L?%);zA)9<(n~b3~t|i5}(oK|9T$-tpbtVI3eeO|bF~ zbE#DMa*s-t?vXGTsHYinL3GThRC&6Wnm6|3dV!o65fuC>5@A>(j{Jd|)jAk6e69 zT&<>9=OaUStyp3d1U^=IvD=JTj*!KpD?CCs?u4yNl@J|kJg)ZS!q9EzJyH3hOo!sg z$P{RaO4)ffCacDuc~YOBCC$+$Z32v7o?@{o!zM1xpX}POrGT%WTp3AME&nQ}d%;R#fSC5mFN(AbgQ>RG@v4Md!_AXzrHy zeePKvXTfqTYq?LLg6qsmxe?g`W;Nk#IcCUhW_S!pA%W!u69$ljSyr$wNP8pU*Qmb; zbMVIy@-h#t-v%s({gAv{%%y(qMCLA6Ziy|)8}g@QovwW~5<~$~v_NN3R`$?P(z&tFB90fdDB;`k9Va?)uzz|uF3 z!@?Le1WUKTJvQG6>m^XVR7XK1Y^1tH6uDd8H&nMwrZXv%yXB8%4HGWl6Xs#e<2l2c zk!HcMXPF__ng3g}AcaVa_EwiDk9*WhIBaMRj3E1yO6c9RKN{pZ!KytWuW&O)t`mDf z>k0`9YfmoogS%!#(a~_%Y%v$)$9M6}(LPOmnESw3F;}dDRivVk69sc$WIkF%Q^dY+?6Y`&~v5_oGnx^Srk_}2W#v#s6g0P80A(yz8P^S9ODf@@S^jR%bH`rtM0+G&Ye#gc1xQhuwD-z&(C?THIR-PEscM_|G`TQpvyoDfB$C<=U&6)0V#%GVFGZ}Qx%r1@R~R%DW% z$XID%SkE(4qWdDJ^731FD{ehs-myBxcm5VzWJW1vRqdU;}HaF*fp z44)MqBORV)16~7cxyB6mW2Ez=-OC12x*~#@mwZuOOtf qPl$lX*bRgoF^xjQhUmx!bR1_G5f4>vAT=WVd-#6@PaPdnBl;KjadGwl diff --git a/test/bytecode_graal312/05_abc_test.graalpy312.pyc b/test/bytecode_graal312/05_abc_test.graalpy312.pyc deleted file mode 100644 index f4a9d608185203d04f08b08176622883aea26233..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 1711 zcmbVM%Wl(95FI~CLz_TJ4MZrLp2Wr z({prt{k`F<9V_UDZPjy)w?}IKDCoM*`r*FitAXhUs&DoBwyF7U=ozNk4m*z?st=xM zdfU)2U+o`BGel3X5WOzvIQ~Y@-4AVZbJPZj49tVpSVAhZR#Gh}0{g<6cwbT^s*AN& zyeG+uJS*3>gyIJFPNglP>uHN<;dhHgigWpO`3v{3An_C}F3DdjQ~|*W4k58HZ!ilT zD**jTwk^l+n?`_CS-#%(15Y=CMfR|OFPaYYOis+cW;ub`@$|rQ9bRz`GJ7XY44pIu z?#~AtaE8b;gV1x1%VR_zV+jt)fWuc<=IEBtx-hWQZwP?USs!s z%8=q`&l}rjpriI6>YMff$T!dxSh5{K*K#`SC&0>`<8rcamF)}4QQfdzL%03SY9rmB z_TaY6GE0h3Cq=whp}K(gCCXcZBBeIoTCMmPJ4P-EJ1P{Y5amlZ0L!Wqz zO0&ET?+Xu0(;U5LY8r~KY3aA1Y5Bx^7wUF83sMKJ3)R*=?i2hq8_2}qaw+hT>*Mm- zK~;9fPhXX(flCJ12sBYEqL|TgQh3}Nz-(63WZDA@Bz9CbE6Y!WEJYr$5PE={ zGzM3>=O2-7*t+jyE(4AM_)nKm16gDXk!QNw$pR&x%b?2&v#F|{%$5uj4xkbeJH6!7Y95rytZZ7 z=f2%;na;*%%QKFfexp-2+OBodHO{(z!){tRnx|)uEj+i=wrr!`Io{ed zHlK>R!^_2y={R-MI;oy@vvWk>CW+pcbDU-S)IIDt_D!X&g=z zE>$duq#{BUh~>eQA4G~Y9RBIKT@MGo6A$-PbN^q`^yxIp8uX2g|kyLH2Yg& z7W6D{hZ2}Xa_b*$%g2Gh(zEV!x8bMme=v>;&;vrW%u`zk97u?$ zIfN(-MxQ#S6U|0rE3Q=to*n_}?BAh^UitctPk4thDX0oDJP9&OfDep44J-%6iC+bj z3c!t$J=;0Lr0X~AHtPh4-AhJnfDjNg%~E2C5)GeM42+;zC75ChnPeO;=mx+oL!tYl z9nmZQ(@X0d@qdQWotI9D+BBBYKGD^hwu)t`u7@2?=R$tRSiVvYUo?hNNkL#{S*P>kU3;LPQC+c!Tk&;r@xjz>5TIQ0~9wi>Mtn=*?73TVO|^ zO`!2|U&&pi?UkPtwWY^#AIe!!n}6Usvefs&h8VGUW66Juzc2S5xm$uZ84cR|*Ls=)}x$RR(j bt862VRRVdQN9@5};2jwSJTeLzy8?d!K4EHC diff --git a/test/bytecode_graal312/05_empty_ifs.graalpy312.pyc b/test/bytecode_graal312/05_empty_ifs.graalpy312.pyc deleted file mode 100644 index 6a03c1f7358bd676f342821d7bc2af52c793fa0d..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 367 zcmaJ+!AiqG5S=y~o0JG*dhjCNg?0t0C-DnBL~1WyhBn={i%B-@ZlpQJU-P3p6ww(f z;zb|K%$t3~&YR2G@el~qeJGs$*+bpFu`Ex7l)^ANU z-mSEgUO6wFF6%;}GmXuaTsE8Qsl1w^Dr?`OUb{)%1}6aT^!5BaqI_GLRa2Ve*1<}W=NV)-)An76jqKk+7?m$8C!hptj1>#zh pKRobiQ4;5?5y`l*9+8?qaYRb^t;SRn3O4s2SpOvO3|Bsg@dci*Mf3mw diff --git a/test/bytecode_graal312/05_if_and_comp.graalpy312.pyc b/test/bytecode_graal312/05_if_and_comp.graalpy312.pyc deleted file mode 100644 index 816763b5f5621050dd197b9fcaa66aba203adaa5..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 1500 zcmaJ>%}*0S6rbrX(o(9@78ImKdNjhKhK&aTH!cb>0tqKK+uZ>g_M_R^3iZUUf13US z9=Lk+#1#{x0pD-S)U6VK@b=An^FHT2c(PNOV1#7;^U)b+?9(0zhKw9ToW>#wY;Wnk zBaOpOeAH_jQRp1^jcz|a3WKFnwM$k>n_zv~H0hP}uUM!R?T!ZcP^tM)6l;pCh_4f^6TUR@;Wj`1{p^sV%E!55jdeM#vxdNII%1` zjR5ACcjyy|xEBTIjSH^70IW17J14;|?W9gOB{2(o| z0dU6?9fY16^gK!L$4i9i8zc?;Twe1+$M)np9h8Cc zCOd}osB-^tlf9Z-;EQaVT5s|<#R5&_wZ6gMwYDBspTTydkGh^-)rxGYqF*Gl6egKX zX0-HLwFcuFoCv5Aw7i0epebTm5BY|ngViO<`;dM6&;jtngOrIdxfT(s2Gj#GHZ@TE z`63*3Ss}7~;kQL(1-36Fq9TbeV%zZ~?12{ z(l!;}ecY;4XJC}|GR-fzR+`}7Cx2z~zng-X$FRS(T3qCTk>ClyO(IkPsNEQhXwco@ yHop*91f+qt8X;uRZ3}@d1XMPR@NcLw;|?()gXis(jf#W+g8v6BR1|Pj2>b>pqwORB diff --git a/test/bytecode_graal312/05_nonlocal.graalpy312.pyc b/test/bytecode_graal312/05_nonlocal.graalpy312.pyc deleted file mode 100644 index 7b204ffa088bfddd658fec36da338fb5c05f7600..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 789 zcmZ`%%}&BV5Z;z5gr5LKq7sqlO%qrXq9+0;uN(jqZw-_UZ75x`+ZwoOAH zerv|ZzQfva9k%}ffg}g)kP^8M28wo|+~^f_2g!0#dxsUZIPn5Z(|{w+og_$?dj=E( z+7>YEYabTDJYTr0YAiOU#&a;`2qI#sS4Ag9moRV9jUx4pPS3Wa=ss(CI z*WO?y{}^bQ6iKg(2?$nzQK_ioBm|q-5@wEe251gViy0oDG8e26nA#PnuEIe^DaWw0 z>9)}dXD-`~$cf<*uo3L>3|dKMb$t3j&1dq;M`3+filR1hMDFboHyMXtG0eDDgfQ_;U+;wmkeDF2G?*w8S_{XBe_@Tep(}t-4 diff --git a/test/bytecode_graal312/05_return_in_else.graalpy312.pyc b/test/bytecode_graal312/05_return_in_else.graalpy312.pyc deleted file mode 100644 index d659598e6c18f581a610fd443d368fa65a991b01..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 1134 zcmZuw-%ry}6h61T>k4CRbR-~iMU9zCf;BN1O^hT)pPXcgnDDlgtz(U)Tl#~*WBae^ zzrbJMgU=FqSdifPN=t^}YtB9Ao_o$c-@WH{<4bj(7|Hz~qoG3deUB$r81yaYIC28t z_BN0Dp>^O!qj=v6#{F+6*5o7_js4Bzfg4(p6Gm3(9!@-`7mnkg?^yfs!OJb{#a1tH zqB!t-uHSRK(0M*NQR_s%RidvgovXY(91mj8c{gi=N&#j=2Fo@zXfNFra#`#uw5+@` z9wQ{x7h3919$`V!Dy8M6SwTH6mx=2~b8JrRAap#}cO*}Su0LRP3y440c(`VN+Pal> zYXX7=koKCz6dH9oDlQqF4O4X63aybz+v20rotLz&tc#9eiX&C;>KesrN5;~KHRC&lhtN1Xs~aF?=Nvs4jCqb| zYAW}m$xBpU6lZnfFI86Lv_jdJRJ3UomkWx}w&&ql*^`Om58%XXFg~Gv)GD~g<6byWSD{|xQ1e??>=!_%%SFZk x6k)_oHVpIAG~>P)Na5KnfU5w*#0`O@wG^69G4*;z|`cAtaDEAO(a3h-1_^+s49;qqQB98=DIs z2EV|O51~{t@6i~w@K(<=JG=8{cKq<|jV%G}-nZ#zCGzzHHeqI>P%m?BX2;3FBFe(k zIG+~d(4^7FRXAVe({y&QoWxm}>nsnm_-vl&QI-}a(&4x`JsO0Ek4L##jXq7|MCYc^ zkLD|zVBC8D$A=C95_edLi(z1-t3C>q^G=otyepl!ds}O>Z?~f!|m~| z9Je4C4T5OsOa{RaY1UI0%DU@@Z+-WC?F6>t*43{jf`K}33YKjvL>i(lmu+qRw7yv1 zdJVa@9zc(+@z=bZP4x1GF{xpLY&_G+2~T5w7T{kn@R~agwGQ6j5Jo6^xFIi6stFP| zK_BG%Sw^<`;aFRj4x*0S-T40*rj%vLY|feLL<6MHPN+_wzm(PJGlnt$$+-i28{7kV l#yBL)jdb}VrpJMF!5(-O)jMt>xC64vzhI1tjMK6T@f%e?YZCwf diff --git a/test/bytecode_graal312/05_while_and_if.graalpy312.pyc b/test/bytecode_graal312/05_while_and_if.graalpy312.pyc deleted file mode 100644 index dc7803989d0a563c7fb20ccf1f3ef4ef83bb2e69..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 825 zcmZuuO>fgc5S@)3CruhcoA4n-Q=|w9A(^cN6|Mk^v831 zIfP1pHk&=;jwwODkD2T&}BTr)YX-^(JAAOv8oE`hq zk$3uJu`+HFeJT;X-K%nq!?R!-&z+;|8jTcSBQ-dVsYUP8H^OX--tIl@rd!Rn@twa= z*8>G`%;4~RWih#q3KojRAAl*tcIc=$^uO+1S+5j7#s)a>lA}X|+xRZ2I%t&E;#gD~ z!$+oGlq%ap%cB0B+%&9JX<6PEeQRm$i&sY-vD@cslA1}~Ewe0sR(^DE5{ELBJQ4b6s_K|1W;P0U^{69dlI0(+i=5T3nDVlb(;@vvB%>klxBB)!H$`w|i;RS>C28=)XrF3H&hliP5&vB_hK z|CxV7AAJ^IBp`jL6zhDKT#{D&@m*$jc6WB>+nL=w-k-TijKOOD%|H-++T(%cdsWNn zD#vr}X6{4Pw~iXB-lvWv`7h1B`X*$Je9V9|TSV^;#i3}7__1dhpTE zwqp+reKVDTbwAI)lL+;<_;;d5N8iA>5GQ(U`G-y!${;vg-e5U=C%u-faOReDRo%1Q zBZtpTU7Z`->v4Mp*mRnn+B&6TUkGeZvM^nf=4po#&r-K}+)rfgMR+Cog_)e^V1{j+ z3u-8*30;qfi`YftGMK%?%Ww(K4OgK9tF?7Z z+Gr{)e*_YhU_qZ}0h_-7?isMUWQ2)A7~B&?hK___ox3q&BQ1=CI!pumg5qE!2Iz;m zom_&eR|4TeK!?jc+81RJHz%dd5`VM$fZOwp(E$Rc(D^cfSWPN^N{Bic@gO)1X5sy} zLYq7}q4qzuUf~@wSOQ_LhNEjOHV#eU z967=RLCvs&F$8Ov<8BNv1`rbAu3vbD*a@>&s diff --git a/test/bytecode_graal312/06_try_return.graalpy312.pyc b/test/bytecode_graal312/06_try_return.graalpy312.pyc deleted file mode 100644 index deb3998f7917a1afb1ac8ec673786b92eed9b875..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 764 zcmaJW z@K?BYAt-u}G_`c$3FqDK`))38=g;yIF@E;m|NSzE9{#c+v{(uUb`FSsnP zSg+-`aoNpl#*0nP*mTCWo3C27_3E&rMzx%sZeF#?t2oadd3m)&(=V^vPd2$!r@F=M z3iji4flaAYqLx`H{?_lrS%f5vt>xebdRuj2BE(_}{N>eiiO*}@?#d$su>TsfJ|PR* zWbRCe?V%2Bfhx1X#D=zLh0m|pr}6zUX@hEXMRx$x7B}HFLdRt943r=jL~M--KZ_~m Pr^Cyc0nDNVvbgpGK$~=* diff --git a/test/bytecode_graal312/06_while_return.graalpy312.pyc b/test/bytecode_graal312/06_while_return.graalpy312.pyc deleted file mode 100644 index b64c1ef01c8974bfe2e1f83d2c96bd4176130ac3..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 1437 zcmbVMOK;Oa5T5lqvFU@RPKuzAfRF%D5!~_!2M|2~w^CK2MHQDScC5xCu`549d&4;( z{udm%_5wG!!Id5gMPWY2iAp0u%V&MFJF`2pvoo8_J)0aO#_J33n?*_V?l~)F7}%z> z9XWwlZ&f>XXl}YuGq%jYw_om_FZ$n zw(+XzvNdp`IPh+6?Z^Vr#}^ zNg0}RMXG6M*Waw>)sn0kEAa20D$K}lEX(o>%PaB|%RA}^mRJM36V%lTXXICw75SOv zRhd_RjD6%8Rt^)1s~ncgL#`KLYWaR^GF9Ektw(%!$7`HEYPiLQKcKO;Cs@=|X{FNM z!(F|&jUdr(c_i+L0T~Q{r0z2-w47%tRu&Y>bwovUgr;aZEg9A<)hF1+j)h?_$wo!4 z=y~cW7nO=)JiS*lmf1ZS6Qt$E_pV+@^sX!=6Cx*6agh5tPU)9SP46cqN_a)r#J*1H z*Hy;#U&(Y*5Cz|uKS1_r4InHC`)~nR9|DWWjt?V3 z8D=x`KN4cBFZOiM?}7JOa$;nLP$#!WTBI!M2B>{U6G1dGr~LS`c6Wq+{F d9>Ei17APGC&+QUxApWra18^IJ#)#4YzX9V@)g%A_ diff --git a/test/bytecode_graal312/07_build_map_unpack.graalpy312.pyc b/test/bytecode_graal312/07_build_map_unpack.graalpy312.pyc deleted file mode 100644 index 98775cbbdf151074e4caf5c8e548f31e4f9ddef4..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 701 zcmb_ZUrQT75TE2Omqe?zxg*vGg9TF|C0#*O5HVOH(uYb>Dp4%wa)`dznUfTK_c!e9&TnRaJGBY|1?00!tVooj=U*Yj1S zmFrx!^2bW&VjHqp?Of?lRY%Np;ZvdB&Ka7nRg0Z>=u3xlM@D(2azOI0A8lAJ!3@mY zYD3UKH^y!n@0I)V?*^bfQsXyk3ni%Bzx}laXv3lg^OZM$=I_*DQH2SpO{p;Xw+6L4 z73xr@3(|wql`PSVEFt+Mt~W(5@p%w`B|>P(WGV5A>KwU19m{npEaR38weOfxl3_y;ynijn{T diff --git a/test/bytecode_graal312/07_forelselast.graalpy312.pyc b/test/bytecode_graal312/07_forelselast.graalpy312.pyc deleted file mode 100644 index f29e435f853c0aa04961e464bec33729e767693c..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 1003 zcmb7DO>fgc5S=)2Vv$s7(g>o~NhA;=id0OC1P2fxp`MxmQt5?DZ{0LEg26|OZlQX7)HBVl@!=t_iq&JgS2k(b9yTYtc|;=(_PIt=PI# z{hgL=Vw6nXN{fBnHYpo=uX3gPr2G1Td1=x1%}9-wMLcw!tu|>}-&B+DR2X_{P zOT=VOtk;5b-d$pzN}1`2t6*(2kmoMrfPwb`-&+9(gWHVU4n9}`DZydO?T5_Ytblmb zh8sbUdxwE{WI=fL;XvQ4GWP!y+D3GZ3Axb)+yw{V#{$PaaW;5^am|u<8+G!>L@yY5 cEHr9|KjPreYAyfX>86CW8OuBb8fhSZ0csVM*Z=?k diff --git a/test/bytecode_graal312/07_kwargs.graalpy312.pyc b/test/bytecode_graal312/07_kwargs.graalpy312.pyc deleted file mode 100644 index 5e9dcc06e4fea160b1e307439ab312b6e9edd793..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 612 zcma)3O-sW-5ZyFQYPF)YdJ%Kz#e-5;D8!4Hqc;&$$gLk~nufMX*(A0-TKpsWPelJh z?_LGLi@6j<=e14Hn=j0~+1Z(w8Fv42eU%Yzcb_{i#7`IGcpxlpk3w5`jb7!(3b^Bj zov6u$Z*|9fFb+GuR~fb3fQNPv^1$s6dUh@FBVpOR897y*A05}a!-jBz!@*eIWb9pH z>{?qP^^?BeihB0x@0ijl6pHr93|5!Sdm~d~hOC=+S6OvSDoK%KJ{n40GSqs`d^juW zRJo(hl(&hjF|vaELH-~+U7nGfs4OE(U*$r6wy~{z=3mQ?+!9Y(^NY72#hr)?Pw03)jxp@xBAYlsO@TB@b;sO}DNn*bW; z$pMTO00U@bXi2j;d=pRvj&l@X1J`rrqc7DnYyiAf?AlC5+p<=BsASjg#-hN1cNGAm`viPhBUEkr_%~H z_7)+85E4sRA%sRO*&^{9*swrsW`x87O*^BuYNK*KCyvs`VvhCQ^WAgL>pJ&3%kSkh zM)KX^uOB`T8T*PJ4B);Rcn^ z3BpR??szT74mw@G?o{q|o3E}_UU}W740g?L+MjfHyqCRwVT`ex3S)QYGgRY^olc|M za&C=sG?EHOgq+#?j7_n%35sPbE^DJeLb&A!_EyK=sfBhos5KqPNt?XOIsI8vZ>wXEN*S$EqXzbBK2ZxB^r}5A}eYl(@qPgMOHkX zKbF`cTa0;CQpKa(X*{DQbU}VR&FG2wi?fof zs9F6LFN#dhi)`wke5ggbAj)TYUJ#`-?cm0&_HeNmkFCUfA+?KV>OpB% zRJ4=vhcETw>{2u%C>ItD?$PYY^G9+tsrF*298F1VIj3r>F8@1sxXkE@it1@Bl%qLS z7tdu?J(`%3GxDFSw8__Eex7W^^06?Pw2|Wu^S$WSl|0c5f~BMUu@v)DA}ftc|CPW+ znaKhjxjcccA#1qx5J%AV{7w_bju*O}wjG4N+inIjS!$l=v>Rakv#$=lYOO%0iPs5S z1kn^;_INy7;VmBwrGu zGyR&vI#cPnZUwEQ_T@a!TK|IIwL9*6T+WYQIF0lu*ROn~oCgdYjN5U}=u z@MORbNEgTmdya;45^N1~#9|*aG{F&r4gKTbfunz%Y4DE-_`d?jUT_=0Q4{A0Kha-= aM+DSE9il@?k5793kat8dO+%oO8uC9wl_|~u diff --git a/test/bytecode_graal312/09_while_if_while.graalpy312.pyc b/test/bytecode_graal312/09_while_if_while.graalpy312.pyc deleted file mode 100644 index 8147826cb48c38f3bc64d41b8fddffe3f7c30361..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 800 zcmZ{h-AWrl6vxkGW4<)Oh8POswzLTzS&i9cKh#`qo}%}C zh(17{!8h;$1aG7tZ2$k74U6Deelusz|IC@0v)iBRHGzG*|MBG(^Uo6uIt*;>Tt`kY zvBsTCJJhFcG>Qj0@a*%c_NURvn{=*+Zm1(CjCAN;_+zIZdU0SodJvz!@9K9S`d1?t zQTOYkv+GZdRgv!nk>iaDPWgD@4db!%Deoh^Fa@s+jzn70ZDOy;tW?j#f=pWjecuW~ zr$6-UXzJrK@gQ^}?#UaIZ#JGye^w~wir@j#1*Xy4!zjJ2f|%-3mDMX{D$^)84y#2m z3#O{{8l{DFuzs)?r_FurOls=atk_PL)!&)XPFB>C`dt#0G*wakS&~+*Tu~3TyQH10 z&LzB3A@8AT%rC+V@i8`sGqx$Pu7*}*aXkSGW8g4bvDaCND*QU&TV8-{G?1~5)iS=! z3jYs-@F>m0yhNHx$_nfXkD~Du`X#{MMy&x>Kod}7{3W2)1}*RgPF`mM*W-y2KsWXmgVNYMpmgS7gYzt?Wr~L!!347E4 diff --git a/test/bytecode_graal312/10_complex.graalpy312.pyc b/test/bytecode_graal312/10_complex.graalpy312.pyc deleted file mode 100644 index b1497b60759968aec3cbdad56754fe743eb17bae..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 3472 zcmbtWT~8ZF6uq-+drfTCuy#m*VmlBeY17~&sI*iF6&jFQM3g2}N?&3b^%^#PQN@-q0Qz?B}msDsuB&qOnSW=PM$gFX5?lUcAq@v02 zyht)KFV-5T9N7Q4`bhW>H+o8ZxW|UVf4cfv@!^KWjSmv8DQ zGJ4xIY<~_6Nm}L=N;R*HzH8WHTBU`K&PYb3)m<^-*Akj%xj1 zbhpXvuvgl$QMQEq)u4xP_k6@Yf>TZb+;qG2w|Bg@j*lH+4<(z+!XQpcfAi}+;8B2w zmj%+mX@ENN9|F{U089W=0CnVFLAWUjxgo!1`yGJ#-I1>F>gopLVeZ9h7Bx?K0H+CP z^Ln$Zp{se_N$V_ZTrFfKltiM0{`;7WIo*VSDvNp$phIK$ z4Wr&qoPYs&q`aARGr&0+zsQwvgTe7K`?*x|OiJ>63VDCFC+mQ(<1QF^CjpKl|1rRE z9|4oVG(a8sD*$zKz$d^0KplC8V6Yx?Tni6?9Opj|(Ecl+8Lr*$LU$jAE#bY-Yhzg< zl^f3+k$Ek)Fe=yOhFaF}_{A172$&XyuWT|&)VA5K|V8_ZP!vFWQ2(Bisk zh0V26N4ilSITysV`sAHwZEX_)0Jwm zP_bvw2y8fKAoO_>xS37MqM7j@yIZ46amx!_Y+kaadK`|ZXVF()kLH|$8@gSo7V11_ zV*DcMGH|4fLBlX&eHq|f6z-)>I9pTM9;b{2YWNj`x@LU5oewwCT@0{kLg7VCc zI9RF!IgQ3~fHkibu9M`Ttf!HqvEyCpbplDrpL9v^c)kcm1AhTJHnXq!oK5=;^8bzTf&)`ezR&; z3;x$lS{&!ANIwEoh&RV55MEMAAUXaAU57V<54Jr`FXeVGMEb#Z(VaH Mu8R z9PGb?zXQP)Zk!O(3UOFYy{*IwR-u%oDl@55(yo>Z6OCrx%)FVO-RSwGPqr<+cErJr|)@#mj**_4&b#6z$Pv`x1z3RQJTnhvcAI(s+dYO^;F_i9C{(`u#WQ??7dVg}&z>YJGTdM)&0{nr z4Tb@!eLDzABETb(j$ykft`Uo?`@3YiSD(a8B>5(UhX)tPD$~vaG?!Vu&|;R^7OOy+ zIfAU;{)GiWMff`+4=USML{Oo^sq7ZB%&D9RZBYXK8@=4(Fp95IEMFEYnJoaJ#b4Q^ zqYJ5$Z3$Zp?!SuAzt~q~BZrr1>XE5?O3wHw56}{?_Ob1^WP#y`zRD~i z$jHllOR5ye8!^pQRzg&S;If)3sC)*nqAr+v+0^HhIU|SXY3f;1=eoi>_alK)HcM|Z z012Cs&J$jV7x_mr6cd(YT;_kryU8-AxrCMZzY--MOG&jD7dX7xXKM0EA}+)$94H0( zH|0Sou9W^RpKD732nqXQ{si|zEuJG$f))D3b9}RaCwK1A$09;I|Z*aV=g1 zk(#uKJk_iNBRs?-hk@_)e8cHr57T5F(fs<6+X+nH9*o=B^n8mVtz*lKLfb=MXoOLK zeM!4bD+oM4O+|~2={b(!cE>YeyWs&8jeN2PdwWtV7tR0w4Ci@JEZxbyxsjC1y7@=u^S9&dkHuaDy`ACkH65h(2m(M3cC&J{B*pkErsFr==$~UhbvotnTPp^zI#66SsC?yLNDB zb+t9^Ze)j==W9MbYglkZS8(T2N88;9RZLL-*J`^xZ6(k?!}n1`WRYXJVX!&EApi{- zI|g3_&aWSBBczh6`4|D`TH zb@#Yh4suToxbC2a!E?AkLWMTdVG&i3Nnb>+rFs?RYO2!(znbbzl$)tewr;BLqx?G6 zze4$As{erUXJo4P6Y@P|fkwM&|O{p6zQ Q@9n>dA|_c#Qf8um08U3n$p8QV diff --git a/test/bytecode_graal312/10_long_pop_jump.graalpy312.pyc b/test/bytecode_graal312/10_long_pop_jump.graalpy312.pyc deleted file mode 100644 index 88e9afa5241f292749b673d8cc5dc4708e6b79a7..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 2747 zcmZuy-EZ4e6u;MYVkb`1G)+I&bxv5jb?UmMY*MucG_O;K1S+T!AP_@}yu@p>CQf8K zUHj;0;$cG51WyPF2_c@~3Go-eD?+?X2qa)a;!B8urUkWYyYf3XZkl$z$?u+X&;6Z` zdmW!lzS0wC827)tbNyVDv9DgoBJa7yyuIq%u47fstQ5WcV%cA6T+6$);__O)zUD90 zoHMJXvX}R5&(C}1YQ16?yjsI8+WBjZ#q%@yXQvC5nzLA_*Xo5EjcWaDeN9d=W+K~b z$225)u39TKD)z;0ohsQK9Eu9O%2Bs6p(0rK;3dZyHK)=70b2!a?K%r z_aNfEV~0`?HA-F15$GQxzz8!WLpmjCm-!XdSU`D=o%9GFVOMxoZf~wgDg(ik)Wkxs z#0)kh8GMeX=O<}jGi9IiB;FMpKn2mn#pYO6n!gL82I63bqU{x|Vb3=r3&}w^BO=GT1TLL(ewc+d z3?eieinnvpQNfzRUd)V}x|w*RgvkA)#L>+jLs8?qwd!V)RJtVH>=joiHg_+{pi7$M zFAbsApYenORn@q}pUCTpRP5g)+d*HD;_I{I?3WcV~CtcKFcgCRB)^ozI~iB6#OY>>(fs4@Oa4&nPnQAdJdI(~}dT~fC= z(}Nz7cC*&89vZBzS~xM)7j-4nH>AsVZ_Q$S7?5s3<_?KaC^s zsi05miRtk~REyo8d^CfbyF|5{`l-{}z4I-T;Unsw*2i1Z44d5hc31F_)Yszg9;NCzeUL_WoMa^wG%; zLA6)wxb*|fZrU^ZX(!xHye<|vV&pL6KT3>qnCY2QTkamz%byxDqvMNl$iC?GhuC*r z+LB`IBXuuyrgv>hSnW%;m;b=V{uH#@qjm*s(~dr63EjIZ2~9$@?G*87$Gpeg)4FnY zcx`2mb714ZQd}Wy6zQN3{oEPb*%5*sR}vaMHF~j50OULd&~M=^KzmcbY^a-%&xiUP zWEmizMS$LgWq^Fhz8dN)kZ%LTy9G3X+W_&%{%)w>g?um6$@W30zYqBdK>i;C9|4~M zSU8ZAP!9P^Ty0L6X>@-}c6z*pFJFk;YYKLQkibsz%* z)$k%f?-23n$3*RcbPFIp>2#0udXi3eMZJaeUjgbZq^B`aE~uSBJ~Vb;Y4YnDwA^(e INnvRG4|h1P`Tzg` diff --git a/test/bytecode_graal312/10_while1_popblock.graalpy312.pyc b/test/bytecode_graal312/10_while1_popblock.graalpy312.pyc deleted file mode 100644 index 392d16013f63cb79bc059f72fbb2e53d67f27644..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 1029 zcmZuw%Wl(95S<%4wiCNeW2F?RY8DV7fr5!DxwP;IgdN=*ci&BPcM=T7quNo=_VvK>1KqcWu4A?Rap-j|y%Y8~H}(4c z_WObDSoO9$b~_Fh-g7713cxW3@M1&4HV=p6Ug%icSx&Ref#ZOP@f@H6TPoH9OmW;y z(1v6yVR)9=8=AJ$HQhJZnA};A?eoSZ#!Dpf&cP!IDOl?OKm!3B2H#+? zTQGQ97n%oK>M=HsitJ=6uSX^RuXLs^+BaN?Zvo z=LL2m{f?>-Re2U&iOcY)O1~0zEs{Br|0ADGx%Eil^W13xR?FPCRlwggca{5@Xr+i3 zK)}Za6nP9k@NAceXO8-ofW&lNYt+jjqw{j?kws_t7GnYOKb?_$b4FrJ_4sPinxJ6N z281#Oy_ Date: Sat, 20 Dec 2025 05:45:27 -0500 Subject: [PATCH 5/6] Go over python_implementation value --- xdis/cross_dis.py | 36 ++++++++++++++++++++++++++-------- xdis/opcodes/opcode_10.py | 9 +++++---- xdis/opcodes/opcode_11.py | 3 ++- xdis/opcodes/opcode_12.py | 3 ++- xdis/opcodes/opcode_13.py | 5 +++-- xdis/opcodes/opcode_14.py | 3 ++- xdis/opcodes/opcode_15.py | 5 +++-- xdis/opcodes/opcode_16.py | 8 +++++--- xdis/opcodes/opcode_20.py | 3 ++- xdis/opcodes/opcode_21.py | 3 ++- xdis/opcodes/opcode_22.py | 17 +++++++++++++++- xdis/opcodes/opcode_23.py | 17 +++++++++++++++- xdis/opcodes/opcode_24.py | 17 +++++++++++++++- xdis/opcodes/opcode_25.py | 17 +++++++++++++++- xdis/opcodes/opcode_26.py | 3 ++- xdis/opcodes/opcode_27.py | 3 ++- xdis/opcodes/opcode_30.py | 17 +++++++++++++++- xdis/opcodes/opcode_31.py | 3 ++- xdis/opcodes/opcode_310.py | 3 ++- xdis/opcodes/opcode_311.py | 3 ++- xdis/opcodes/opcode_312.py | 21 ++++++++++++++++++-- xdis/opcodes/opcode_312rust.py | 19 ++++++++++++++++-- xdis/opcodes/opcode_313.py | 24 +++++++++++++++++++++-- xdis/opcodes/opcode_313rust.py | 15 ++++++++++++++ xdis/opcodes/opcode_314.py | 22 ++++++++++++++++++++- xdis/opcodes/opcode_32.py | 3 ++- xdis/opcodes/opcode_33.py | 5 +++-- xdis/opcodes/opcode_34.py | 5 +++-- xdis/opcodes/opcode_35.py | 8 ++++---- xdis/opcodes/opcode_37.py | 4 ++-- xdis/opcodes/opcode_38.py | 5 +++-- xdis/opcodes/opcode_39.py | 8 ++++---- 32 files changed, 259 insertions(+), 58 deletions(-) diff --git a/xdis/cross_dis.py b/xdis/cross_dis.py index 57a57f1c..80c41357 100644 --- a/xdis/cross_dis.py +++ b/xdis/cross_dis.py @@ -44,9 +44,13 @@ def _try_compile(source: str, name: str) -> CodeType: return c -def code_info(x, version_tuple: Tuple[int, ...], python_implementation: PythonImplementation) -> str: +def code_info( + x, version_tuple: Tuple[int, ...], python_implementation: PythonImplementation +) -> str: """Formatted details of methods, functions, or code.""" - return format_code_info(get_code_object(x), version_tuple, python_implementation=python_implementation) + return format_code_info( + get_code_object(x), version_tuple, python_implementation=python_implementation + ) def get_code_object(x): @@ -259,7 +263,12 @@ def op_has_argument(opcode: int, opc) -> bool: """ Return True if `opcode` instruction has an operand. """ - return opcode in opc.hasarg if hasattr(opc, "hasarg") else opcode >= opc.HAVE_ARGUMENT + return ( + opcode in opc.hasarg + if hasattr(opc, "hasarg") + and opc.python_implementation is PythonImplementation.RustPython + else opcode >= opc.HAVE_ARGUMENT + ) def pretty_flags(flags, python_implementation=PYTHON_IMPLEMENTATION) -> str: @@ -269,7 +278,10 @@ def pretty_flags(flags, python_implementation=PYTHON_IMPLEMENTATION) -> str: for i in range(32): flag = 1 << i if flags & flag: - if python_implementation == PythonImplementation.PyPy and flag in PYPY_COMPILER_FLAG_NAMES: + if ( + python_implementation == PythonImplementation.PyPy + and flag in PYPY_COMPILER_FLAG_NAMES + ): names.append(PYPY_COMPILER_FLAG_NAMES.get(flag, hex(flag))) else: names.append(COMPILER_FLAG_NAMES.get(flag, hex(flag))) @@ -320,7 +332,9 @@ def format_code_info( pass if version_tuple >= (1, 3): - lines.append("# Flags: %s" % pretty_flags(co.co_flags, python_implementation)) + lines.append( + "# Flags: %s" % pretty_flags(co.co_flags, python_implementation) + ) if version_tuple >= (1, 5): lines.append("# First Line: %s" % co.co_firstlineno) @@ -373,7 +387,9 @@ def format_exception_table(bytecode, version_tuple) -> str: for entry in bytecode.exception_entries: lasti = " lasti" if entry.lasti else "" end = entry.end - 2 - lines.append(f" {entry.start} to {end} -> {entry.target} [{entry.depth}]{lasti}") + lines.append( + f" {entry.start} to {end} -> {entry.target} [{entry.depth}]{lasti}" + ) return "\n".join(lines) @@ -414,7 +430,11 @@ def unpack_opargs_bytecode(code, opc): offset += 1 if op_has_argument(op, opc): arg = code2num(code, offset) | extended_arg - extended_arg = extended_arg_val(opc, arg) if hasattr(opc, "EXTENDED_ARG") and op == opc.EXTENDED_ARG else 0 + extended_arg = ( + extended_arg_val(opc, arg) + if hasattr(opc, "EXTENDED_ARG") and op == opc.EXTENDED_ARG + else 0 + ) offset += 2 else: arg = None @@ -474,7 +494,7 @@ def xstack_effect(opcode, opc, oparg: int = 0, jump=None): if opname == "BUILD_MAP" and version_tuple >= (3, 5): return 1 - (2 * oparg) if opname in ("UNPACK_SEQUENCE",): - return oparg - 1 + return oparg - 1 elif opname in ("UNPACK_EX"): return (oparg & 0xFF) + (oparg >> 8) elif opname == "BUILD_INTERPOLATION": diff --git a/xdis/opcodes/opcode_10.py b/xdis/opcodes/opcode_10.py index d3f513b2..ff0abf78 100644 --- a/xdis/opcodes/opcode_10.py +++ b/xdis/opcodes/opcode_10.py @@ -1,4 +1,4 @@ -# (C) Copyright 2019-2023 by Rocky Bernstein +# (C) Copyright 2019-2023, 2025 by Rocky Bernstein # # This program is free software; you can redistribute it and/or # modify it under the terms of the GNU General Public License @@ -16,8 +16,8 @@ """ CPython 1.0 bytecode opcodes -This is used in bytecode disassembly. This is similar to the -opcodes in Python's dis.py library. +This is like Python 1.0's dis.py with some classification +of stack usage and information for formatting instructions. """ import xdis.opcodes.opcode_11 as opcode_11 @@ -25,7 +25,7 @@ # This is used from outside this module from xdis.cross_dis import findlabels # noqa from xdis.opcodes.base import ( # Although these aren't used here, they are exported; noqa - cpython_implementation as python_implementation, + cpython_implementation, finalize_opcodes, init_opdata, name_op, @@ -35,6 +35,7 @@ from xdis.opcodes.opcode_11 import opcode_arg_fmt11, opcode_extended_fmt11 version_tuple = (1, 0) +python_implementation = cpython_implementation loc = locals() init_opdata(loc, opcode_11, version_tuple) diff --git a/xdis/opcodes/opcode_11.py b/xdis/opcodes/opcode_11.py index d2a12bc4..b68c9bf3 100644 --- a/xdis/opcodes/opcode_11.py +++ b/xdis/opcodes/opcode_11.py @@ -25,7 +25,7 @@ # This is used from outside this module from xdis.cross_dis import findlabels from xdis.opcodes.base import ( # Although these aren't used here, they are exported; noqa - cpython_implementation as python_implementation, + cpython_implementation, finalize_opcodes, init_opdata, update_pj2, @@ -33,6 +33,7 @@ from xdis.opcodes.opcode_12 import opcode_arg_fmt12, opcode_extended_fmt12 version_tuple = (1, 1) # 1.2 is the same +python_implementation = cpython_implementation loc = locals() init_opdata(loc, opcode_12, version_tuple) diff --git a/xdis/opcodes/opcode_12.py b/xdis/opcodes/opcode_12.py index 021587bc..0029a016 100644 --- a/xdis/opcodes/opcode_12.py +++ b/xdis/opcodes/opcode_12.py @@ -25,7 +25,7 @@ # This is used from outside this module from xdis.cross_dis import findlabels # noqa from xdis.opcodes.base import ( # Although these aren't used here, they are exported; noqa - cpython_implementation as python_implementation, + cpython_implementation, finalize_opcodes, init_opdata, name_op, @@ -36,6 +36,7 @@ from xdis.opcodes.opcode_13 import opcode_arg_fmt13, opcode_extended_fmt13 version_tuple = (1, 2) +python_implementation = cpython_implementation loc = locals() init_opdata(loc, opcode_13, version_tuple) diff --git a/xdis/opcodes/opcode_13.py b/xdis/opcodes/opcode_13.py index 416467ef..7b69bc60 100644 --- a/xdis/opcodes/opcode_13.py +++ b/xdis/opcodes/opcode_13.py @@ -24,8 +24,8 @@ # This is used from outside this module from xdis.cross_dis import findlabels # noqa -from xdis.opcodes.base import ( # Although these aren't used here, they are exported; noqa - cpython_implementation as python_implementation, +from xdis.opcodes.base import ( + cpython_implementation, def_op, finalize_opcodes, init_opdata, @@ -35,6 +35,7 @@ from xdis.opcodes.opcode_1x import opcode_extended_fmt_base1x, update_arg_fmt_base1x version_tuple = (1, 3) +python_implementation = cpython_implementation loc = locals() init_opdata(loc, opcode_14, version_tuple) diff --git a/xdis/opcodes/opcode_14.py b/xdis/opcodes/opcode_14.py index b8d24453..8879d0c6 100644 --- a/xdis/opcodes/opcode_14.py +++ b/xdis/opcodes/opcode_14.py @@ -25,6 +25,7 @@ # This is used from outside this module from xdis.cross_dis import findlabels # noqa from xdis.opcodes.base import ( # Although these aren't used here, they are exported + cpython_implementation, def_op, finalize_opcodes, init_opdata, @@ -35,7 +36,7 @@ from xdis.opcodes.opcode_1x import opcode_extended_fmt_base1x, update_arg_fmt_base1x version_tuple = (1, 4) -python_implementation = "CPython" +python_implementation = cpython_implementation loc = locals() init_opdata(loc, opcode_15, version_tuple) diff --git a/xdis/opcodes/opcode_15.py b/xdis/opcodes/opcode_15.py index c0e666be..2825ea8b 100644 --- a/xdis/opcodes/opcode_15.py +++ b/xdis/opcodes/opcode_15.py @@ -16,14 +16,14 @@ """ CPython 1.5 bytecode opcodes -This is a like Python 1.5's opcode.py with some classification +This is a like Python 1.5's dis.py with some classification of stack usage and information for formatting instructions. of stack usage. """ import xdis.opcodes.opcode_1x as opcode_1x from xdis.opcodes.base import ( # Although these aren't used here, they are exported; noqa - cpython_implementation as python_implementation, + cpython_implementation, finalize_opcodes, init_opdata, update_pj2, @@ -31,6 +31,7 @@ from xdis.opcodes.opcode_1x import opcode_extended_fmt_base1x, update_arg_fmt_base1x version_tuple = (1, 5) +python_implementation = cpython_implementation loc = locals() diff --git a/xdis/opcodes/opcode_16.py b/xdis/opcodes/opcode_16.py index 3cc46b70..97a13868 100644 --- a/xdis/opcodes/opcode_16.py +++ b/xdis/opcodes/opcode_16.py @@ -16,8 +16,9 @@ """ CPython 1.6 bytecode opcodes -This is used in bytecode disassembly. This is similar to the -opcodes in Python's dis.py library. +This is a like Python 1.6's dis.py with some classification +of stack usage and information for formatting instructions. +of stack usage. """ import xdis.opcodes.opcode_15 as opcode_15 @@ -26,7 +27,7 @@ from xdis.cross_dis import findlabels, findlinestarts # noqa from xdis.opcodes.base import ( # noqa call_op, - cpython_implementation as python_implementation, + cpython_implementation, finalize_opcodes, init_opdata, update_pj2, @@ -34,6 +35,7 @@ from xdis.opcodes.opcode_2x import opcode_extended_fmt_base2x, update_arg_fmt_base2x version_tuple = (1, 6) +python_implementation = cpython_implementation loc = locals() diff --git a/xdis/opcodes/opcode_20.py b/xdis/opcodes/opcode_20.py index 0941f960..5dab63d5 100644 --- a/xdis/opcodes/opcode_20.py +++ b/xdis/opcodes/opcode_20.py @@ -21,7 +21,7 @@ import xdis.opcodes.opcode_21 as opcode_21 from xdis.opcodes.base import ( # noqa - cpython_implementation as python_implementation, + cpython_implementation, finalize_opcodes, init_opdata, rm_op, @@ -30,6 +30,7 @@ from xdis.opcodes.opcode_2x import opcode_extended_fmt_base2x, update_arg_fmt_base2x version_tuple = (2, 0) +python_implementation = cpython_implementation loc = locals() init_opdata(loc, opcode_21, version_tuple) diff --git a/xdis/opcodes/opcode_21.py b/xdis/opcodes/opcode_21.py index e3340587..210aa591 100644 --- a/xdis/opcodes/opcode_21.py +++ b/xdis/opcodes/opcode_21.py @@ -21,7 +21,7 @@ import xdis.opcodes.opcode_22 as opcode_22 from xdis.opcodes.base import ( # noqa - cpython_implementation as python_implementation, + cpython_implementation, finalize_opcodes, init_opdata, rm_op, @@ -30,6 +30,7 @@ from xdis.opcodes.opcode_2x import opcode_extended_fmt_base2x, update_arg_fmt_base2x version_tuple = (2, 1) +python_implementation = cpython_implementation loc = locals() init_opdata(loc, opcode_22, version_tuple) diff --git a/xdis/opcodes/opcode_22.py b/xdis/opcodes/opcode_22.py index b8effafa..520bf865 100644 --- a/xdis/opcodes/opcode_22.py +++ b/xdis/opcodes/opcode_22.py @@ -1,4 +1,18 @@ # (C) Copyright 2017, 2019, 2021, 2023, 2025 by Rocky Bernstein +# +# This program is free software; you can redistribute it and/or +# modify it under the terms of the GNU General Public License +# as published by the Free Software Foundation; either version 2 +# of the License, or (at your option) any later version. +# +# This program is distributed in the hope that it will be useful, +# but WITHOUT ANY WARRANTY; without even the implied warranty of +# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +# GNU General Public License for more details. +# +# You should have received a copy of the GNU General Public License +# along with this program; if not, write to the Free Software +# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. """ CPython 2.2 bytecode opcodes @@ -7,7 +21,7 @@ import xdis.opcodes.opcode_2x as opcode_2x from xdis.opcodes.base import ( # noqa - cpython_implementation as python_implementation, + cpython_implementation, def_op, finalize_opcodes, init_opdata, @@ -16,6 +30,7 @@ from xdis.opcodes.opcode_2x import opcode_extended_fmt_base2x, update_arg_fmt_base2x version_tuple = (2, 2) +python_implementation = cpython_implementation loc = locals() init_opdata(loc, opcode_2x, version_tuple) diff --git a/xdis/opcodes/opcode_23.py b/xdis/opcodes/opcode_23.py index 2035dd43..df871638 100644 --- a/xdis/opcodes/opcode_23.py +++ b/xdis/opcodes/opcode_23.py @@ -1,4 +1,18 @@ # (C) Copyright 2017, 2019-2021, 2023 by Rocky Bernstein +# +# This program is free software; you can redistribute it and/or +# modify it under the terms of the GNU General Public License +# as published by the Free Software Foundation; either version 2 +# of the License, or (at your option) any later version. +# +# This program is distributed in the hope that it will be useful, +# but WITHOUT ANY WARRANTY; without even the implied warranty of +# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +# GNU General Public License for more details. +# +# You should have received a copy of the GNU General Public License +# along with this program; if not, write to the Free Software +# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. """ CPython 2.3 bytecode opcodes @@ -8,7 +22,7 @@ import xdis.opcodes.opcode_2x as opcode_2x from xdis.opcodes.base import ( # noqa - cpython_implementation as python_implementation, + cpython_implementation, finalize_opcodes, init_opdata, update_pj2, @@ -16,6 +30,7 @@ from xdis.opcodes.opcode_2x import opcode_extended_fmt_base2x, update_arg_fmt_base2x version_tuple = (2, 3) +python_implementation = cpython_implementation loc = locals() init_opdata(loc, opcode_2x, version_tuple) diff --git a/xdis/opcodes/opcode_24.py b/xdis/opcodes/opcode_24.py index 5f8eb6ac..b0e93e40 100644 --- a/xdis/opcodes/opcode_24.py +++ b/xdis/opcodes/opcode_24.py @@ -1,4 +1,18 @@ # (C) Copyright 2017, 2020-2021, 2023 by Rocky Bernstein +# +# This program is free software; you can redistribute it and/or +# modify it under the terms of the GNU General Public License +# as published by the Free Software Foundation; either version 2 +# of the License, or (at your option) any later version. +# +# This program is distributed in the hope that it will be useful, +# but WITHOUT ANY WARRANTY; without even the implied warranty of +# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +# GNU General Public License for more details. +# +# You should have received a copy of the GNU General Public License +# along with this program; if not, write to the Free Software +# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. """ CPython 2.4 bytecode opcodes @@ -8,7 +22,7 @@ import xdis.opcodes.opcode_2x as opcode_2x from xdis.opcodes.base import ( # noqa - cpython_implementation as python_implementation, + cpython_implementation, def_op, finalize_opcodes, init_opdata, @@ -17,6 +31,7 @@ from xdis.opcodes.opcode_2x import opcode_extended_fmt_base2x, update_arg_fmt_base2x version_tuple = (2, 4) +python_implementation = cpython_implementation loc = locals() init_opdata(loc, opcode_2x, version_tuple) diff --git a/xdis/opcodes/opcode_25.py b/xdis/opcodes/opcode_25.py index 3ef75652..c710e7ed 100644 --- a/xdis/opcodes/opcode_25.py +++ b/xdis/opcodes/opcode_25.py @@ -1,4 +1,18 @@ # (C) Copyright 2017, 2020-2021, 2023 by Rocky Bernstein +# +# This program is free software; you can redistribute it and/or +# modify it under the terms of the GNU General Public License +# as published by the Free Software Foundation; either version 2 +# of the License, or (at your option) any later version. +# +# This program is distributed in the hope that it will be useful, +# but WITHOUT ANY WARRANTY; without even the implied warranty of +# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +# GNU General Public License for more details. +# +# You should have received a copy of the GNU General Public License +# along with this program; if not, write to the Free Software +# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. """ CPython 2.5 bytecode opcodes @@ -8,7 +22,7 @@ import xdis.opcodes.opcode_24 as opcode_24 from xdis.opcodes.base import ( # noqa - cpython_implementation as python_implementation, + cpython_implementation, def_op, finalize_opcodes, init_opdata, @@ -17,6 +31,7 @@ from xdis.opcodes.opcode_2x import opcode_extended_fmt_base2x, update_arg_fmt_base2x version_tuple = (2, 5) +python_implementation = cpython_implementation loc = locals() init_opdata(loc, opcode_24, version_tuple) diff --git a/xdis/opcodes/opcode_26.py b/xdis/opcodes/opcode_26.py index d0839261..57ec226a 100644 --- a/xdis/opcodes/opcode_26.py +++ b/xdis/opcodes/opcode_26.py @@ -22,7 +22,7 @@ import xdis.opcodes.opcode_25 as opcode_25 from xdis.opcodes.base import ( # noqa - cpython_implementation as python_implementation, + cpython_implementation, finalize_opcodes, init_opdata, name_op, @@ -33,6 +33,7 @@ from xdis.opcodes.opcode_2x import opcode_extended_fmt_base2x, update_arg_fmt_base2x version_tuple = (2, 6) +python_implementation = cpython_implementation loc = locals() init_opdata(loc, opcode_25, version_tuple) diff --git a/xdis/opcodes/opcode_27.py b/xdis/opcodes/opcode_27.py index 2a074a69..f30762f2 100644 --- a/xdis/opcodes/opcode_27.py +++ b/xdis/opcodes/opcode_27.py @@ -23,7 +23,7 @@ import xdis.opcodes.opcode_26 as opcode_26 from xdis.opcodes.base import ( # noqa compare_op, - cpython_implementation as python_implementation, + cpython_implementation, def_op, finalize_opcodes, init_opdata, @@ -37,6 +37,7 @@ from xdis.opcodes.opcode_2x import opcode_extended_fmt_base2x, update_arg_fmt_base2x version_tuple = (2, 7) +python_implementation = cpython_implementation loc = locals() init_opdata(loc, opcode_26, version_tuple) diff --git a/xdis/opcodes/opcode_30.py b/xdis/opcodes/opcode_30.py index 7597c2d6..f53ac197 100644 --- a/xdis/opcodes/opcode_30.py +++ b/xdis/opcodes/opcode_30.py @@ -1,4 +1,18 @@ # (C) Copyright 2017, 2019-2021, 2023-2025 by Rocky Bernstein +# +# This program is free software; you can redistribute it and/or +# modify it under the terms of the GNU General Public License +# as published by the Free Software Foundation; either version 2 +# of the License, or (at your option) any later version. +# +# This program is distributed in the hope that it will be useful, +# but WITHOUT ANY WARRANTY; without even the implied warranty of +# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +# GNU General Public License for more details. +# +# You should have received a copy of the GNU General Public License +# along with this program; if not, write to the Free Software +# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. """ CPython 3.0 bytecode opcodes @@ -8,7 +22,7 @@ import xdis.opcodes.opcode_31 as opcode_31 from xdis.opcodes.base import ( # noqa - cpython_implementation as python_implementation, + cpython_implementation, def_op, finalize_opcodes, init_opdata, @@ -19,6 +33,7 @@ from xdis.opcodes.opcode_33 import opcode_arg_fmt33, opcode_extended_fmt33 version_tuple = (3, 0) +python_implementation = cpython_implementation loc = locals() diff --git a/xdis/opcodes/opcode_31.py b/xdis/opcodes/opcode_31.py index f85074e5..17e41d60 100644 --- a/xdis/opcodes/opcode_31.py +++ b/xdis/opcodes/opcode_31.py @@ -8,7 +8,7 @@ import xdis.opcodes.opcode_32 as opcode_32 from xdis.opcodes.base import ( # noqa - cpython_implementation as python_implementation, + cpython_implementation, def_op, finalize_opcodes, init_opdata, @@ -21,6 +21,7 @@ loc = locals() version_tuple = (3, 1) +python_implementation = cpython_implementation init_opdata(loc, opcode_32, version_tuple) diff --git a/xdis/opcodes/opcode_310.py b/xdis/opcodes/opcode_310.py index 62fcbd79..409aebf4 100644 --- a/xdis/opcodes/opcode_310.py +++ b/xdis/opcodes/opcode_310.py @@ -23,7 +23,7 @@ import xdis.opcodes.opcode_39 as opcode_39 from xdis.cross_dis import findlinestarts # noqa from xdis.opcodes.base import ( # noqa - cpython_implementation as python_implementation, + cpython_implementation, def_op, finalize_opcodes, init_opdata, @@ -33,6 +33,7 @@ from xdis.opcodes.opcode_39 import opcode_arg_fmt39, opcode_extended_fmt39 version_tuple = (3, 10) +python_implementation = cpython_implementation loc = locals() diff --git a/xdis/opcodes/opcode_311.py b/xdis/opcodes/opcode_311.py index aa953bf0..fad7ce4a 100644 --- a/xdis/opcodes/opcode_311.py +++ b/xdis/opcodes/opcode_311.py @@ -27,6 +27,7 @@ from xdis.instruction import Instruction from xdis.opcodes.base import ( binary_op, + cpython_implementation, def_op, finalize_opcodes, free_op, @@ -45,7 +46,7 @@ from xdis.opcodes.opcode_310 import opcode_arg_fmt310, opcode_extended_fmt310 version_tuple = (3, 11) -python_implementation = "CPython" +python_implementation = cpython_implementation # oppush[op] => number of stack entries pushed oppush: List[int] = [0] * 256 diff --git a/xdis/opcodes/opcode_312.py b/xdis/opcodes/opcode_312.py index e60f4037..49bc7835 100644 --- a/xdis/opcodes/opcode_312.py +++ b/xdis/opcodes/opcode_312.py @@ -1,13 +1,30 @@ +# (C) Copyright 2025 by Rocky Bernstein +# +# This program is free software; you can redistribute it and/or +# modify it under the terms of the GNU General Public License +# as published by the Free Software Foundation; either version 2 +# of the License, or (at your option) any later version. +# +# This program is distributed in the hope that it will be useful, +# but WITHOUT ANY WARRANTY; without even the implied warranty of +# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +# GNU General Public License for more details. +# +# You should have received a copy of the GNU General Public License +# along with this program; if not, write to the Free Software +# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. """ CPython 3.12 bytecode opcodes -This is like Python 3.12's opcode.py with some classification +This is like Python 3.12's opcode.py with some classification of stack usage and information for formatting instructions. +This has similar imformation as the opcodes in Python's opcode.py library. """ import xdis.opcodes.opcode_311 as opcode_311 from xdis.opcodes.base import ( binary_op, + cpython_implementation, def_op, finalize_opcodes, init_opdata, @@ -20,7 +37,7 @@ from xdis.opcodes.opcode_311 import opcode_arg_fmt311, opcode_extended_fmt311 version_tuple = (3, 12) -python_implementation = "CPython" +python_implementation = cpython_implementation loc = locals() diff --git a/xdis/opcodes/opcode_312rust.py b/xdis/opcodes/opcode_312rust.py index 3e06b0b9..b657b0c6 100644 --- a/xdis/opcodes/opcode_312rust.py +++ b/xdis/opcodes/opcode_312rust.py @@ -1,6 +1,20 @@ +# (C) Copyright 2019-2023, 2025 by Rocky Bernstein +# +# This program is free software; you can redistribute it and/or +# modify it under the terms of the GNU General Public License +# as published by the Free Software Foundation; either version 2 +# of the License, or (at your option) any later version. +# +# This program is distributed in the hope that it will be useful, +# but WITHOUT ANY WARRANTY; without even the implied warranty of +# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +# GNU General Public License for more details. +# +# You should have received a copy of the GNU General Public License +# along with this program; if not, write to the Free Software +# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. """ -RustPython 3.12 bytecode opcodes - +RustPython 3.12 bytecode opcodes. """ #FIXME: this needs a lot of going over. @@ -108,6 +122,7 @@ def pseudo_op(name: str, op: int, real_ops: list): oplist.append(op) +# See RustPython/compiler/core/src/bytecode.rs Instruction # fmt: off # OP NAME OPCODE POP PUSH diff --git a/xdis/opcodes/opcode_313.py b/xdis/opcodes/opcode_313.py index c54caaba..e160a82d 100644 --- a/xdis/opcodes/opcode_313.py +++ b/xdis/opcodes/opcode_313.py @@ -1,5 +1,24 @@ +# (C) Copyright 2025 by Rocky Bernstein +# +# This program is free software; you can redistribute it and/or +# modify it under the terms of the GNU General Public License +# as published by the Free Software Foundation; either version 2 +# of the License, or (at your option) any later version. +# +# This program is distributed in the hope that it will be useful, +# but WITHOUT ANY WARRANTY; without even the implied warranty of +# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +# GNU General Public License for more details. +# +# You should have received a copy of the GNU General Public License +# along with this program; if not, write to the Free Software +# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. """ -CPython 3.13 bytecode opcodes +CPython 3.13 bytecode opcodes. + +This is like Python 3.13's opcode.py with some classification +of stack usage and information for formatting instructions. +This has similar imformation as the opcodes in Python's opcode.py library. """ from typing import Optional, Tuple @@ -7,7 +26,7 @@ import xdis.opcodes.opcode_312 as opcode_312 from xdis.opcodes.base import ( # noqa VARYING_STACK_INT, - cpython_implementation as python_implementation, + cpython_implementation, def_op, finalize_opcodes, free_op, @@ -20,6 +39,7 @@ from xdis.opcodes.opcode_36pypy import format_CALL_METHOD version_tuple = (3, 13) +python_implementation = cpython_implementation loc = locals() diff --git a/xdis/opcodes/opcode_313rust.py b/xdis/opcodes/opcode_313rust.py index 9723f6c3..85422adc 100644 --- a/xdis/opcodes/opcode_313rust.py +++ b/xdis/opcodes/opcode_313rust.py @@ -1,3 +1,18 @@ +# (C) Copyright 2019-2023, 2025 by Rocky Bernstein +# +# This program is free software; you can redistribute it and/or +# modify it under the terms of the GNU General Public License +# as published by the Free Software Foundation; either version 2 +# of the License, or (at your option) any later version. +# +# This program is distributed in the hope that it will be useful, +# but WITHOUT ANY WARRANTY; without even the implied warranty of +# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +# GNU General Public License for more details. +# +# You should have received a copy of the GNU General Public License +# along with this program; if not, write to the Free Software +# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. """ RustPython 3.13 bytecode opcodes diff --git a/xdis/opcodes/opcode_314.py b/xdis/opcodes/opcode_314.py index 02a6e761..5a2466d9 100644 --- a/xdis/opcodes/opcode_314.py +++ b/xdis/opcodes/opcode_314.py @@ -1,5 +1,24 @@ +# (C) Copyright 2025 by Rocky Bernstein +# +# This program is free software; you can redistribute it and/or +# modify it under the terms of the GNU General Public License +# as published by the Free Software Foundation; either version 2 +# of the License, or (at your option) any later version. +# +# This program is distributed in the hope that it will be useful, +# but WITHOUT ANY WARRANTY; without even the implied warranty of +# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +# GNU General Public License for more details. +# +# You should have received a copy of the GNU General Public License +# along with this program; if not, write to the Free Software +# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. """ CPython 3.14 bytecode opcodes + +This is a like Python 3.14's opcode.py with some classification +of stack usage and information for formatting instructions. +of stack usage. """ from xdis.opcodes.base import ( # noqa @@ -8,7 +27,7 @@ call_op, compare_op, const_op, - cpython_implementation as python_implementation, + cpython_implementation, def_op, finalize_opcodes, free_op, @@ -23,6 +42,7 @@ ) version_tuple = (3, 14) +python_implementation = cpython_implementation loc = locals() diff --git a/xdis/opcodes/opcode_32.py b/xdis/opcodes/opcode_32.py index 32715e03..0724f752 100644 --- a/xdis/opcodes/opcode_32.py +++ b/xdis/opcodes/opcode_32.py @@ -8,7 +8,7 @@ import xdis.opcodes.opcode_3x as opcode_3x from xdis.opcodes.base import ( # noqa - cpython_implementation as python_implementation, + cpython_implementation, finalize_opcodes, init_opdata, update_pj3, @@ -18,6 +18,7 @@ # FIXME: can we DRY this even more? version_tuple = (3, 2) +python_implementation = cpython_implementation loc = locals() diff --git a/xdis/opcodes/opcode_33.py b/xdis/opcodes/opcode_33.py index 175d6c3c..5cb63a75 100644 --- a/xdis/opcodes/opcode_33.py +++ b/xdis/opcodes/opcode_33.py @@ -1,4 +1,4 @@ -# (C) Copyright 2017, 2020-2021, 2023 by Rocky Bernstein +# (C) Copyright 2017, 2020-2021, 2023, 2025 by Rocky Bernstein """ CPython 3.3 bytecode opcodes @@ -8,7 +8,7 @@ import xdis.opcodes.opcode_3x as opcode_3x from xdis.opcodes.base import ( # noqa - cpython_implementation as python_implementation, + cpython_implementation, def_op, finalize_opcodes, init_opdata, @@ -20,6 +20,7 @@ from xdis.opcodes.opcode_3x import format_MAKE_FUNCTION_30_35 version_tuple = (3, 3) +python_implementation = cpython_implementation loc = locals() init_opdata(loc, opcode_3x, version_tuple) diff --git a/xdis/opcodes/opcode_34.py b/xdis/opcodes/opcode_34.py index 2d91d0d0..89a38720 100644 --- a/xdis/opcodes/opcode_34.py +++ b/xdis/opcodes/opcode_34.py @@ -21,8 +21,8 @@ """ import xdis.opcodes.opcode_33 as opcode_33 -from xdis.opcodes.base import ( # noqa - cpython_implementation as python_implementation, +from xdis.opcodes.base import ( + cpython_implementation, finalize_opcodes, free_op, init_opdata, @@ -32,6 +32,7 @@ from xdis.opcodes.opcode_33 import opcode_arg_fmt33, opcode_extended_fmt33 version_tuple = (3, 4) +python_implementation = cpython_implementation loc = locals() diff --git a/xdis/opcodes/opcode_35.py b/xdis/opcodes/opcode_35.py index 5136c39e..657f6917 100644 --- a/xdis/opcodes/opcode_35.py +++ b/xdis/opcodes/opcode_35.py @@ -1,4 +1,4 @@ -# (C) Copyright 2016-2017, 2020-2021, 2023 by Rocky Bernstein +# (C) Copyright 2016-2017, 2020-2021, 2023, 2025 by Rocky Bernstein # # This program is free software; you can redistribute it and/or # modify it under the terms of the GNU General Public License @@ -24,8 +24,8 @@ from typing import Optional, Tuple import xdis.opcodes.opcode_34 as opcode_34 -from xdis.opcodes.base import ( # noqa - cpython_implementation as python_implementation, +from xdis.opcodes.base import ( + cpython_implementation, def_op, finalize_opcodes, init_opdata, @@ -38,7 +38,7 @@ from xdis.opcodes.opcode_34 import opcode_arg_fmt34, opcode_extended_fmt34 version_tuple = (3, 5) - +python_implementation = cpython_implementation loc = locals() diff --git a/xdis/opcodes/opcode_37.py b/xdis/opcodes/opcode_37.py index 0683c1cc..32cdcde5 100644 --- a/xdis/opcodes/opcode_37.py +++ b/xdis/opcodes/opcode_37.py @@ -26,7 +26,7 @@ import xdis.opcodes.opcode_36 as opcode_36 from xdis.opcodes.base import ( # noqa call_op, - cpython_implementation as python_implementation, + cpython_implementation, def_op, finalize_opcodes, init_opdata, @@ -46,7 +46,7 @@ ) version_tuple = (3, 7) -python_implementation = "CPython" +python_implementation = cpython_implementation loc = locals() diff --git a/xdis/opcodes/opcode_38.py b/xdis/opcodes/opcode_38.py index d1e1594b..fde08200 100644 --- a/xdis/opcodes/opcode_38.py +++ b/xdis/opcodes/opcode_38.py @@ -21,8 +21,8 @@ """ import xdis.opcodes.opcode_37 as opcode_37 -from xdis.opcodes.base import ( # noqa - cpython_implementation as python_implementation, +from xdis.opcodes.base import ( + cpython_implementation, def_op, finalize_opcodes, init_opdata, @@ -34,6 +34,7 @@ from xdis.opcodes.opcode_37 import opcode_arg_fmt37, opcode_extended_fmt37 version_tuple = (3, 8) +python_implementation = cpython_implementation loc = locals() diff --git a/xdis/opcodes/opcode_39.py b/xdis/opcodes/opcode_39.py index 983c3696..3040fa74 100644 --- a/xdis/opcodes/opcode_39.py +++ b/xdis/opcodes/opcode_39.py @@ -1,4 +1,4 @@ -# (C) Copyright 2019-2021, 2023-2024 by Rocky Bernstein +# (C) Copyright 2019-2021, 2023-2025 by Rocky Bernstein # # This program is free software; you can redistribute it and/or # modify it under the terms of the GNU General Public License @@ -23,9 +23,9 @@ from typing import Optional, Tuple import xdis.opcodes.opcode_38 as opcode_38 -from xdis.opcodes.base import ( # noqa +from xdis.opcodes.base import ( binary_op, - cpython_implementation as python_implementation, + cpython_implementation, def_op, finalize_opcodes, init_opdata, @@ -37,7 +37,7 @@ from xdis.opcodes.opcode_38 import opcode_arg_fmt38, opcode_extended_fmt38 version_tuple = (3, 9) -python_implementation = "CPython" +python_implementation = cpython_implementation loc = locals() From 5fc58a167be019e374ee423539f8d8eb52820935 Mon Sep 17 00:00:00 2001 From: rocky Date: Sun, 21 Dec 2025 11:57:29 -0500 Subject: [PATCH 6/6] Reinstate Graal bytecode --- ...c-notyet => 01_comprehension.graalpy311.pyc} | Bin ...py311.pyc-notyet => 02_async.graalpy311.pyc} | Bin ...1.pyc-notyet => 02_async_for.graalpy311.pyc} | Bin ...et => 02_async_for_generator.graalpy311.pyc} | Bin .../02_build_list_unpack.graalpy311.pyc | Bin 0 -> 1286 bytes ...02_build_map_unpack_with_call.graalpy311.pyc | Bin 0 -> 329 bytes ....pyc-notyet => 02_call_ex_kw.graalpy311.pyc} | Bin .../bytecode_graal311/02_complex.graalpy311.pyc | Bin 0 -> 288 bytes .../02_fn_varargs.graalpy311.pyc | Bin 0 -> 518 bytes .../bytecode_graal311/02_genexpr.graalpy311.pyc | Bin 0 -> 806 bytes .../02_if_not_or.graalpy311.pyc | Bin 0 -> 1498 bytes .../02_ifelse_comprehension.graalpy311.pyc | Bin 0 -> 1315 bytes test/bytecode_graal311/02_kwargs.graalpy311.pyc | Bin 0 -> 998 bytes .../02_tryfinally_return.graalpy311.pyc | Bin 0 -> 545 bytes .../02_var_annotate.graalpy311.pyc | Bin 0 -> 561 bytes test/bytecode_graal311/02_while1.graalpy311.pyc | Bin 0 -> 972 bytes .../02_while1_if_while1.graalpy311.pyc | Bin 0 -> 828 bytes .../02_while1else.graalpy311.pyc} | Bin 997 -> 971 bytes .../02_while_and.graalpy311.pyc | Bin 0 -> 434 bytes .../03_async_await.graalpy311.pyc | Bin 0 -> 2818 bytes .../03_build_tuple_call.graalpy311.pyc | Bin 0 -> 597 bytes .../03_double_star_unpack.graalpy311.pyc | Bin 0 -> 866 bytes .../03_else_removal.graalpy311.pyc | Bin 0 -> 570 bytes .../03_extendedarg.graalpy311.pyc | Bin 0 -> 605 bytes .../03_fn_defaults.graalpy311.pyc | Bin 0 -> 1297 bytes test/bytecode_graal311/03_ifelse.graalpy311.pyc | Bin 0 -> 2405 bytes .../03_ifelse_chained_for.graalpy311.pyc | Bin 0 -> 830 bytes test/bytecode_graal311/04_withas.graalpy311.pyc | Bin 0 -> 2063 bytes .../00_chained-compare.graalpy312.pyc | Bin 0 -> 456 bytes .../01_chained_compare.graalpy312.pyc | Bin 0 -> 1610 bytes .../01_comprehension.graalpy312.pyc | Bin 0 -> 1253 bytes .../01_if_try_except.graalpy312.pyc | Bin 0 -> 904 bytes .../01_try_else.graalpy312.pyc | Bin 0 -> 856 bytes .../01_try_except.graalpy312.pyc | Bin 0 -> 901 bytes test/bytecode_graal312/02_async.graalpy312.pyc | Bin 0 -> 1282 bytes .../02_async_for.graalpy312.pyc | Bin 0 -> 1059 bytes .../02_async_for_generator.graalpy312.pyc | Bin 0 -> 2019 bytes .../02_call_ex_kw.graalpy312.pyc | Bin 0 -> 2581 bytes .../02_try_except_except.graalpy312.pyc | Bin 0 -> 1055 bytes .../02_tryfinally_return.graalpy312.pyc | Bin 0 -> 546 bytes .../02_while1_if_while1.graalpy312.pyc | Bin 0 -> 829 bytes .../02_while1else.graalpy312.pyc | Bin 0 -> 972 bytes .../03_async_await.graalpy312.pyc | Bin 0 -> 2819 bytes .../03_double_star_unpack.graalpy312.pyc | Bin 0 -> 867 bytes .../03_else_removal.graalpy312.pyc | Bin 0 -> 571 bytes .../03_extendedarg.graalpy312.pyc | Bin 0 -> 606 bytes .../03_fn_defaults.graalpy312.pyc | Bin 0 -> 1298 bytes test/bytecode_graal312/03_if_try.graalpy312.pyc | Bin 0 -> 653 bytes test/bytecode_graal312/03_ifelse.graalpy312.pyc | Bin 0 -> 2406 bytes .../03_ifelse_chained_for.graalpy312.pyc | Bin 0 -> 831 bytes .../03_jump_to_jump.graalpy312.pyc | Bin 0 -> 2413 bytes .../bytecode_graal312/03_pop_top.graalpy312.pyc | Bin 0 -> 960 bytes .../03_raise_from.graalpy312.pyc | Bin 0 -> 533 bytes .../03_try_return_except.graalpy312.pyc | Bin 0 -> 1109 bytes .../03_while-if-break.graalpy312.pyc | Bin 0 -> 681 bytes .../03_while_else.graalpy312.pyc | Bin 0 -> 611 bytes .../bytecode_graal312/04_and_del.graalpy312.pyc | Bin 0 -> 1578 bytes .../04_async_stmt.graalpy312.pyc | Bin 0 -> 684 bytes .../04_aug_assign.graalpy312.pyc | Bin 0 -> 666 bytes .../04_for_no_jump_back.graalpy312.pyc | Bin 0 -> 766 bytes .../bytecode_graal312/04_grammar.graalpy312.pyc | Bin 0 -> 5306 bytes .../04_importlist.graalpy312.pyc | Bin 0 -> 581 bytes .../04_lambda_star_default.graalpy312.pyc | Bin 0 -> 966 bytes .../04_try_finally.graalpy312.pyc | Bin 0 -> 1980 bytes test/bytecode_graal312/04_withas.graalpy312.pyc | Bin 0 -> 2064 bytes .../05-for-ifelse.graalpy312.pyc | Bin 0 -> 748 bytes .../05_36lambda.graalpy312.pyc | Bin 0 -> 2345 bytes .../05_abc_test.graalpy312.pyc | Bin 0 -> 1711 bytes .../05_block_fallback.graalpy312.pyc | Bin 0 -> 1890 bytes .../05_empty_ifs.graalpy312.pyc | Bin 0 -> 367 bytes .../05_if_and_comp.graalpy312.pyc | Bin 0 -> 1500 bytes .../05_nonlocal.graalpy312.pyc | Bin 0 -> 789 bytes .../05_return_in_else.graalpy312.pyc | Bin 0 -> 1134 bytes .../05_store_locals.graalpy312.pyc | Bin 0 -> 839 bytes .../05_try_whiletrue.graalpy312.pyc | Bin 0 -> 771 bytes .../05_while_and_if.graalpy312.pyc | Bin 0 -> 825 bytes .../06_listcomp.graalpy312.pyc | Bin 0 -> 1438 bytes .../06_try_return.graalpy312.pyc | Bin 0 -> 764 bytes .../06_while_return.graalpy312.pyc | Bin 0 -> 1437 bytes .../07_build_map_unpack.graalpy312.pyc | Bin 0 -> 701 bytes .../07_forelselast.graalpy312.pyc | Bin 0 -> 1003 bytes test/bytecode_graal312/07_kwargs.graalpy312.pyc | Bin 0 -> 612 bytes .../09_ext_arg_jump.graalpy312.pyc | Bin 0 -> 1956 bytes .../09_while_if_while.graalpy312.pyc | Bin 0 -> 800 bytes .../bytecode_graal312/10_complex.graalpy312.pyc | Bin 0 -> 3472 bytes .../10_extended_arg_loop.graalpy312.pyc | Bin 0 -> 1979 bytes .../10_long_pop_jump.graalpy312.pyc | Bin 0 -> 2747 bytes .../10_while1_popblock.graalpy312.pyc | Bin 0 -> 1029 bytes xdis/load.py | 6 ++++++ 89 files changed, 6 insertions(+) rename test/bytecode_graal311/{01_comprehension.graalpy311.pyc-notyet => 01_comprehension.graalpy311.pyc} (100%) rename test/bytecode_graal311/{02_async.graalpy311.pyc-notyet => 02_async.graalpy311.pyc} (100%) rename test/bytecode_graal311/{02_async_for.graalpy311.pyc-notyet => 02_async_for.graalpy311.pyc} (100%) rename test/bytecode_graal311/{02_async_for_generator.graalpy311.pyc-notyet => 02_async_for_generator.graalpy311.pyc} (100%) create mode 100644 test/bytecode_graal311/02_build_list_unpack.graalpy311.pyc create mode 100644 test/bytecode_graal311/02_build_map_unpack_with_call.graalpy311.pyc rename test/bytecode_graal311/{02_call_ex_kw.graalpy311.pyc-notyet => 02_call_ex_kw.graalpy311.pyc} (100%) create mode 100644 test/bytecode_graal311/02_complex.graalpy311.pyc create mode 100644 test/bytecode_graal311/02_fn_varargs.graalpy311.pyc create mode 100644 test/bytecode_graal311/02_genexpr.graalpy311.pyc create mode 100644 test/bytecode_graal311/02_if_not_or.graalpy311.pyc create mode 100644 test/bytecode_graal311/02_ifelse_comprehension.graalpy311.pyc create mode 100644 test/bytecode_graal311/02_kwargs.graalpy311.pyc create mode 100644 test/bytecode_graal311/02_tryfinally_return.graalpy311.pyc create mode 100644 test/bytecode_graal311/02_var_annotate.graalpy311.pyc create mode 100644 test/bytecode_graal311/02_while1.graalpy311.pyc create mode 100644 test/bytecode_graal311/02_while1_if_while1.graalpy311.pyc rename test/{bytecode_graal310/02_while1else.graalpy310.pyc-notyet => bytecode_graal311/02_while1else.graalpy311.pyc} (60%) create mode 100644 test/bytecode_graal311/02_while_and.graalpy311.pyc create mode 100644 test/bytecode_graal311/03_async_await.graalpy311.pyc create mode 100644 test/bytecode_graal311/03_build_tuple_call.graalpy311.pyc create mode 100644 test/bytecode_graal311/03_double_star_unpack.graalpy311.pyc create mode 100644 test/bytecode_graal311/03_else_removal.graalpy311.pyc create mode 100644 test/bytecode_graal311/03_extendedarg.graalpy311.pyc create mode 100644 test/bytecode_graal311/03_fn_defaults.graalpy311.pyc create mode 100644 test/bytecode_graal311/03_ifelse.graalpy311.pyc create mode 100644 test/bytecode_graal311/03_ifelse_chained_for.graalpy311.pyc create mode 100644 test/bytecode_graal311/04_withas.graalpy311.pyc create mode 100644 test/bytecode_graal312/00_chained-compare.graalpy312.pyc create mode 100644 test/bytecode_graal312/01_chained_compare.graalpy312.pyc create mode 100644 test/bytecode_graal312/01_comprehension.graalpy312.pyc create mode 100644 test/bytecode_graal312/01_if_try_except.graalpy312.pyc create mode 100644 test/bytecode_graal312/01_try_else.graalpy312.pyc create mode 100644 test/bytecode_graal312/01_try_except.graalpy312.pyc create mode 100644 test/bytecode_graal312/02_async.graalpy312.pyc create mode 100644 test/bytecode_graal312/02_async_for.graalpy312.pyc create mode 100644 test/bytecode_graal312/02_async_for_generator.graalpy312.pyc create mode 100644 test/bytecode_graal312/02_call_ex_kw.graalpy312.pyc create mode 100644 test/bytecode_graal312/02_try_except_except.graalpy312.pyc create mode 100644 test/bytecode_graal312/02_tryfinally_return.graalpy312.pyc create mode 100644 test/bytecode_graal312/02_while1_if_while1.graalpy312.pyc create mode 100644 test/bytecode_graal312/02_while1else.graalpy312.pyc create mode 100644 test/bytecode_graal312/03_async_await.graalpy312.pyc create mode 100644 test/bytecode_graal312/03_double_star_unpack.graalpy312.pyc create mode 100644 test/bytecode_graal312/03_else_removal.graalpy312.pyc create mode 100644 test/bytecode_graal312/03_extendedarg.graalpy312.pyc create mode 100644 test/bytecode_graal312/03_fn_defaults.graalpy312.pyc create mode 100644 test/bytecode_graal312/03_if_try.graalpy312.pyc create mode 100644 test/bytecode_graal312/03_ifelse.graalpy312.pyc create mode 100644 test/bytecode_graal312/03_ifelse_chained_for.graalpy312.pyc create mode 100644 test/bytecode_graal312/03_jump_to_jump.graalpy312.pyc create mode 100644 test/bytecode_graal312/03_pop_top.graalpy312.pyc create mode 100644 test/bytecode_graal312/03_raise_from.graalpy312.pyc create mode 100644 test/bytecode_graal312/03_try_return_except.graalpy312.pyc create mode 100644 test/bytecode_graal312/03_while-if-break.graalpy312.pyc create mode 100644 test/bytecode_graal312/03_while_else.graalpy312.pyc create mode 100644 test/bytecode_graal312/04_and_del.graalpy312.pyc create mode 100644 test/bytecode_graal312/04_async_stmt.graalpy312.pyc create mode 100644 test/bytecode_graal312/04_aug_assign.graalpy312.pyc create mode 100644 test/bytecode_graal312/04_for_no_jump_back.graalpy312.pyc create mode 100644 test/bytecode_graal312/04_grammar.graalpy312.pyc create mode 100644 test/bytecode_graal312/04_importlist.graalpy312.pyc create mode 100644 test/bytecode_graal312/04_lambda_star_default.graalpy312.pyc create mode 100644 test/bytecode_graal312/04_try_finally.graalpy312.pyc create mode 100644 test/bytecode_graal312/04_withas.graalpy312.pyc create mode 100644 test/bytecode_graal312/05-for-ifelse.graalpy312.pyc create mode 100644 test/bytecode_graal312/05_36lambda.graalpy312.pyc create mode 100644 test/bytecode_graal312/05_abc_test.graalpy312.pyc create mode 100644 test/bytecode_graal312/05_block_fallback.graalpy312.pyc create mode 100644 test/bytecode_graal312/05_empty_ifs.graalpy312.pyc create mode 100644 test/bytecode_graal312/05_if_and_comp.graalpy312.pyc create mode 100644 test/bytecode_graal312/05_nonlocal.graalpy312.pyc create mode 100644 test/bytecode_graal312/05_return_in_else.graalpy312.pyc create mode 100644 test/bytecode_graal312/05_store_locals.graalpy312.pyc create mode 100644 test/bytecode_graal312/05_try_whiletrue.graalpy312.pyc create mode 100644 test/bytecode_graal312/05_while_and_if.graalpy312.pyc create mode 100644 test/bytecode_graal312/06_listcomp.graalpy312.pyc create mode 100644 test/bytecode_graal312/06_try_return.graalpy312.pyc create mode 100644 test/bytecode_graal312/06_while_return.graalpy312.pyc create mode 100644 test/bytecode_graal312/07_build_map_unpack.graalpy312.pyc create mode 100644 test/bytecode_graal312/07_forelselast.graalpy312.pyc create mode 100644 test/bytecode_graal312/07_kwargs.graalpy312.pyc create mode 100644 test/bytecode_graal312/09_ext_arg_jump.graalpy312.pyc create mode 100644 test/bytecode_graal312/09_while_if_while.graalpy312.pyc create mode 100644 test/bytecode_graal312/10_complex.graalpy312.pyc create mode 100644 test/bytecode_graal312/10_extended_arg_loop.graalpy312.pyc create mode 100644 test/bytecode_graal312/10_long_pop_jump.graalpy312.pyc create mode 100644 test/bytecode_graal312/10_while1_popblock.graalpy312.pyc diff --git a/test/bytecode_graal311/01_comprehension.graalpy311.pyc-notyet b/test/bytecode_graal311/01_comprehension.graalpy311.pyc similarity index 100% rename from test/bytecode_graal311/01_comprehension.graalpy311.pyc-notyet rename to test/bytecode_graal311/01_comprehension.graalpy311.pyc diff --git a/test/bytecode_graal311/02_async.graalpy311.pyc-notyet b/test/bytecode_graal311/02_async.graalpy311.pyc similarity index 100% rename from test/bytecode_graal311/02_async.graalpy311.pyc-notyet rename to test/bytecode_graal311/02_async.graalpy311.pyc diff --git a/test/bytecode_graal311/02_async_for.graalpy311.pyc-notyet b/test/bytecode_graal311/02_async_for.graalpy311.pyc similarity index 100% rename from test/bytecode_graal311/02_async_for.graalpy311.pyc-notyet rename to test/bytecode_graal311/02_async_for.graalpy311.pyc diff --git a/test/bytecode_graal311/02_async_for_generator.graalpy311.pyc-notyet b/test/bytecode_graal311/02_async_for_generator.graalpy311.pyc similarity index 100% rename from test/bytecode_graal311/02_async_for_generator.graalpy311.pyc-notyet rename to test/bytecode_graal311/02_async_for_generator.graalpy311.pyc diff --git a/test/bytecode_graal311/02_build_list_unpack.graalpy311.pyc b/test/bytecode_graal311/02_build_list_unpack.graalpy311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..6ee5743f0352e2fded002dd29288c3eb1ffc8380 GIT binary patch literal 1286 zcmb7DOLG!I5T4lwyF5}FcF~kcAf(DmEL;P66HCqAL)MfB4-}70SVLgL?pknM%JPrt zU-0PNqX$h%NQwOoyGSY*ZRnn!Z@PQt>xMmhEyGBnt-To((!-&v~}$<1vY-yW$gxMTLx_Dylq7=hT#ZnfY;NwsjE|2&eBvW>JaG>GUEh zkxyS>$Prj!L;jWoFH+C}w49pFnlK|67v>!`hM`|FkbVIEK}fBY$T{8@wkm9mfNO#l zesz(DLWqI?6PxCj?Unp}K#3q`jkL(lnNEi5_RIV_0a2Dq{5SOj_A)bFMb+$Ft7JPx?v za;|D1CF%A-ev^)(tW1+m>4Fc9Huk=o)6Jx3SbI(%g`q9dr2x1_5Ko0*kR?)FpNPcd zMYq5yri$}q=ol3mg5zwA8?@pQ^!^6*k!Zj;Za@ur$HI~$1PCg6+%6Z{(N2-SF6VC% z5aswhLv%Ab|Ftqi#N#&c%Nvuklp92I@e#`Zo#Zk;9;&z;D*@sr?7?l96#wXd f5;TWpQSyHTfPpv3PEy_#G(Jf0Z)=$qY$tX?IFUn8OuGBB6 zEXl~v)2&F!EY>ecEiTb7&de>yNsTYgFD*(=)lVu-H#XHbFp5tq&CE%O&rK|dFU>1R zOwNuk2bvO}oS2iNS5V0;z`$?-XqPMpkg&fPpv3PEy_#G(Jf0Z)=$qY$tX?IFUn8OuGBB6 zEXl~v)2&F!EY>ecEiTb7&de>yNsTYgFD*(=)i*GTPtFGkROl5{G7B&;YycW5%K;>8 za`RJ4b5iY)*+5}9U<9(*fY_cvguz4zq>6><4R7KAH+7zKa?@1`)Jh=DjF c4#+|*P!5O&Spvcc0OI`z0+0xZ2AK&00PU1Axc~qF literal 0 HcmV?d00001 diff --git a/test/bytecode_graal311/02_fn_varargs.graalpy311.pyc b/test/bytecode_graal311/02_fn_varargs.graalpy311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..e8c17fc59c68c5b82388794ca1227ce7163340e0 GIT binary patch literal 518 zcmZutJ5Iwu5Zw^RSV%|^(E$Z*q_7A~2ONO{(^0G(XJcFVr`>fFcbJ|-q~#iL1vmmX zprC?zhL{BL?3wpG<9TE6z}wtlguA`x=#lv8niAJ4;Bsc9%KT(F4Kxp96O|*b^5C}O zMP;Hq8_veD=0MLJ``mm_FTZ}z)7~6Mf!C9J* z%S2u*Ybv+slG>(lZ)>qM@h)Scsu}$C;B!wy)==iSfL(ar4gp<&qa^d`IeDp#4tG-Fa|~Y_x)A zSeL%%-1lX-A2hwrPVcs5WS~tTO{?8?wK87lJ6hJm#=)W7-B%6W(Y>x;?)Jy$iJr!Y ziaBPt+um*H>gs6B=@f#aEZY^)B2@~rC_LKfA6!X`QYNe`g^p36{8|J@+%OWdiWC`+ z3TzfF(*<3ME0MEk=HyrumN@%3lcBwQiTF30`Q-Iu@B3(+3!tB3Q_68`#wZ0&a2f61 zO|bWZruNa5Za5x{A&Ktu*CH6~_=>8lyot4zZP#;ZuBn#ODy9-Zz#5xHr_1ZY5}TB@ zCh45nEKzglY^hSP(93$WVopp=eB~+sRuUo_JPGntIzR^lQefp>9MNJMsQe`x$pq*{ zaV7RPdx#-|EMScmhC#AoB#O|48%mxZFBLJqy?h)a7cqttQN-I6m<4b+4#ivh3rr4c R|K-7lF#>EciWGcu@jslCd;$Of literal 0 HcmV?d00001 diff --git a/test/bytecode_graal311/02_if_not_or.graalpy311.pyc b/test/bytecode_graal311/02_if_not_or.graalpy311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..53717746943c3cb77a78038b5e75a71d6380135d GIT binary patch literal 1498 zcmaJ=T~8B16rI^G3T1(oFTc8LB5E{&HE80C@tuG?z_V%E?N};px9o0}K5qYpKgZv| zzcBH^puu49oUX%Hk&~RAJ9qBAbLY(L^IdmJ0IOe)-`lnjUw1JHk~j?1VXES8t-bmw zOoC=B-RswbI12X%L2r=mMcviIMk@(Ym83z^>h#*Gnne9LR6)JpeEB+fv0iO`sCJ{Y z8pUh9fjK8c9rY^()PK{78vV9`1X7cMP#$yeh9SVrZAh;fxqs z)8x?AmL9pAiBKM`snU+>)K#3!U{+1`YK`c#YE&DoFr6Lqtiy8!EOS)3TIlMG5gN3g zfSxFBJoHV^aKt+YQ@LF*#DU>UPaen#>B~*eljSu;X0!J3(3}^bWoEOJr>{BW1tSC}WQN%rP8f24z-het$$x9yAg$#KpC)|zkRGPNFPukbjr+UoMic(>%IQ_Z0H~bnm zxbjAj1W?}hKK~!3`OdlF zO-l2i4KCg;H%mMMiKigtX3xNd-1&S=bmjt3of+IqtIjt~dmg<0>hnr>d-=mF8R5 cH8^q|!#VVysk_Wy!1?lp!3CYnksA_!0RSD#`v3p{ literal 0 HcmV?d00001 diff --git a/test/bytecode_graal311/02_ifelse_comprehension.graalpy311.pyc b/test/bytecode_graal311/02_ifelse_comprehension.graalpy311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..101654931a291779256a46a4dbfc5828470674e7 GIT binary patch literal 1315 zcmb7D%}(1u5MHnC{9pxW9HAC9pa}H<5-}tkdPqx4GbnJyLD zlFoH0f4|Lj-j;Q_t>|*^Hp5s5|8+SQ)A6Jw=tTir-0FRr2!X+&9u1%2(no z`Hc88`7?230#TlYmDz_1bF>W=$!yCHWRjK>z&vza8>Sz4$Uu{v0USrJOZ*1q$-2NI zKNtlU5-I%)YB4jnQ_)C8^St_JtD71nC!`WzCamx->q=eTm0v6SQel~`usun8x+j$% zQ#911un_Szb_*h|7w43p3(>DEBZ{?1Q7;K7AJr8J!kLVO*AGN?f7G6o4rZq1C%lpH zChnKS{|!+jX(7Tm1F5(PGCSv09M?J)jyM^6yAQ}nn^|w!uGzQ!-TEwu4Kl*wM}!sj zqP8m4Sf|WbP3jal8>=ss8YjrTTHj=^R(HyKST*fN#OI|bE)leFDaWrCsO*Ij{}C>Q z6&}UKh!^8q8i(agY(s>zf%+CIvIw*L_2D!q*Ac$Cv{c>oo#yk~Sw%?q=9H zj**@4(I<67G#@3 ICMS~bH%x-b=Kufz literal 0 HcmV?d00001 diff --git a/test/bytecode_graal311/02_kwargs.graalpy311.pyc b/test/bytecode_graal311/02_kwargs.graalpy311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..f533139d614b528ea69ae38a4af6bcd173e89dd1 GIT binary patch literal 998 zcmbVK&2G~`5T3OinzkyclBg$=q8=iF5{w`M4v0(DYlZ5g50T?+ey9^~y*5p_B@e(m zz$5SkP@bVj1UIBg93ufjD)Ys5C{hoISh(11N!`6{+ z%SkMwu@^L7`r7Uf<3ZA~qtHK|+G-jP!f|ub9cnw4I=1z2qypL2VG{Y$?j-$(kL>#o z+Q+9})Ytda)Z8XIF^Q^04*ql$c9TFpyQ(9DoGe!A%tu5OQdAXpL`9Uvj^VtI$Tb4j zblx5uS+p-IW~=lV*XCv&JTKCAx@KaX%G9`Je%~xxKQ}%%s4=5iaegV5l2!hY6&~Zn zh;v?N(M!gD9EO305kyJb_xyomKWh8oNDaA2<;Ca=Lw`|$t@COYDia8v6Z9v{HQJ$? za6Tw-VFLsGn4%GqO6u$~z z>fF3~2Akqy?=~NN-J@(FGoCVSF)J_95_OH_I7WV8ErT8$@Gp>ut;4(`+&^60;60Km zjN%1=UKp+%STQmKEx{mB_Wx4eLd3Xaf(`k}LBz!xZzFG_hp*%U&&5+EyXV#G26i2W z@^XTXVhXJi{>-_-&E^FNlppi>Qy|>|A6^AE*#HRHWX|pbTIxt1MlP4mILs(-9tMOw Q(7=Bucq1}ytX^RKH_!#CD*ylh literal 0 HcmV?d00001 diff --git a/test/bytecode_graal311/02_tryfinally_return.graalpy311.pyc b/test/bytecode_graal311/02_tryfinally_return.graalpy311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..6a39cc5605de19d176f0bb4e65a87d7c04b089b2 GIT binary patch literal 545 zcmZus!A^rf5FJXX#8jfhYh&Wkq^?oo$@Bwy@Sw*=iKW|?NCB5c;aL8}Z}H~6e`BKa z8fZx4BX5V9H~VJx;_>K^7@P0Wx#wJ5cPrCb_l+NeEV8PO-J`t^jsV7h1(F6R+#|vBkl-mGfLgyMGyuy0J*LCN lV%vuyHrO^p!E7YpFQaimgoYZ29roRuP3i`u%@xGP?hm&jP7VM7 literal 0 HcmV?d00001 diff --git a/test/bytecode_graal311/02_var_annotate.graalpy311.pyc b/test/bytecode_graal311/02_var_annotate.graalpy311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..0abeef37cae205de99d3e022624186be14c0002d GIT binary patch literal 561 zcmbtQ%}T>S5Z>)3X;YLI6ZO=CM+?KH!;* zUQ4b@GnQ$u7z)iztPR&^tRkm+?4x}~Lvz1-n^Xm`n#BX@i za~dF9?$yB~);iv{g=5igI%n3pPQd0a{i2Mmn*?lbQ=6`w6DEk$b#%iXagIO63IZyqy;h9EG=ZJg8=VmxQQb zdTw-v%aMB#WcymU#du4KyeV+E&_G5~{RE&a6(ufx1fwkL_G?oHE|r;X*EI!d>lNks z3%Mv48JAya8gQmTT{EEejLRH!UeB4pfy>5yoH~@CYH@b7PMM|J35Q&Wt0boMcW9Q9 ztU6W_OHrjO-D0B*Jj^ME{Kx#Blqv z94e~%h%9cy8&R`IBbxjc$oQr)#S}J*beus=H&0i)c-`qdrU@(4aPz%3pRmB1>l?LL zlxFBK0F(c#Q7&DPc0rnUR+#BEjC(V^gYoH1Q?7!f`UB)X@(@Y&6=Zd$Ut;_))5jPm o2wICdo%n!Fh1ARi&UE&3c5K*O|zBDEy^14Z(Q?EnA( literal 0 HcmV?d00001 diff --git a/test/bytecode_graal311/02_while1_if_while1.graalpy311.pyc b/test/bytecode_graal311/02_while1_if_while1.graalpy311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..0002ff639756da27eeec120d9bab80cf4521dbdb GIT binary patch literal 828 zcmaJfgc5S_JC+p0qdE~rYNfdlOUskqSGXgE~jlA;{i8y72eHjUN9HftN2qy4`) z!C&Z4=(V><5UDEjtQv(%@T}Q+GkH57j$fTTSSLpQ?8jtZ5Pko|ftx7bl^3a0;c&Y9 z#ZTO`Af05Vu8REgxf{>ZNfhp0jDo~XWs zw06ZO*s5V{ohxEe&l~evo>ymnoP}vHlOL3dl#Sowp-Lnl!x=|^0n025K9o!|6<%)L z)87jruYk@k**fAgnaz*fxI>%N6Nh5Z)WAhgI~32w(TlFL&ANPD=haQxtP8R&?WcX6 zw|ITBP5qa>)ael(6h)IYHb3G$YD~sKI6{&?1WKTg;fT*aKx(i+xPasx7=XKYA3%ex z#fFLX@~tuX56Vq%p+*%%WrqDNqnZZoI(IpCCGc-l+NvwQ7icT2@+$W)kGoYrXiyXP Mu^DDzSNf{vZ(7xb00000 literal 0 HcmV?d00001 diff --git a/test/bytecode_graal310/02_while1else.graalpy310.pyc-notyet b/test/bytecode_graal311/02_while1else.graalpy311.pyc similarity index 60% rename from test/bytecode_graal310/02_while1else.graalpy310.pyc-notyet rename to test/bytecode_graal311/02_while1else.graalpy311.pyc index abf9f3f5eeb70894b0f3c07f45557db242bbc333..891e7d4e942ef319c5da40daab65deb593276270 100644 GIT binary patch delta 84 zcmaFLewv+8Ya(L?C$j(pLl83qgY3j2BW^|(5e8cZli;Qxrits#8JQU=U|{&l z1|*77OG=CKzH$MX0htA<&N-Q>c_mk6CaW_>GdfRhW}LqqgdJv^vJV+~b#gB`Kv?mXWm)-;kZL&6tX%e!DHsHm-8a?bgYiD%>Tu9NuCY-ePmNsbGv0f}d z6YnZ$;hPPswd%b6+<0oQqm8c>z}aCZCXJIBP#j{m;dz&A)}!(l*vg~g$gqjC8$bL~ hxnmJ|D}(Dck-zXC8hg5w7{|wslZJHDcGCb$N}F~OD?lnnYPcYTR#XCME3F`i1EgIR9SxWu< ztq5)$4PF0i;zuLzc>9N8>>dS^M<@Gk6b_%9yW{i8qj0o+b`Zqw#E&O#96TK#`-3<< ziH5$re{!_*vHQ`^z>CjE!-03|1(OfQ=am(uev-4+>vF=UPs4+gWB;@1Ibj$`B71gfv9o2UFRn@NcYpPxAwZ33gYA?goQE8!~q z)?$_{s$?;(sH9c=5#xevMoDzs1M+(f=`f76uw(@PIQF$BbCv>Wsi~JDd9hZI${}Az z!V);?*?Re`vcxijicGeJ8|qCp{_1n9**j=>!#&4$_G(|+U8`$%tX(y&RlU|HvLIPo zP-}PWU)L_TRO$2klB(5fNu#2wmy7C#&xNeEh0DTl?2iV+a5VCVlOP-s&At~gkcMt` z5Y}WG`QCvaF*}U{d4yzAfP5Yz(RV5(_147jj__VilQ^dXM@SSD;FUmt0@hs#5ZN2P zA!L8%cZArVt(Tfz62zqd`)mmBTU$%c@>D0fqV8IIs}CxNz1EI+r1t8zXT>5MCRa@&^*FxGRMY4MYSO^<87g_%T&=YK+4$3 z?gn(9>)7c^`@JqRVq8Tdzyi>54kN@btMcqyG^-Kk0%Uhrc>e|U{@&@@z1FUH>6+)) zfVmFljiu_Rw&}!0el!OYde#GGKjs!akm>*22pR||9E~9D8&EWY2($KIWzN&xpo;|k zwvfta&YA9dXUGL#)?{5O-)v<`oC@%Ez9;OcpmhIqtd82XRPXV$_DQcLx4KG}tv{0$ zHUBTES8LW~U9O6HdgaXbE4H9zCWoLZ!Z->>6B$b&LwyBt^-vD3B3^%%GGEMzjX5@B zr!-qR@dxc}(ANojQixXp{*;?FS=s5jcRKYGGNZuPfa1R|99yO0ccmK}H&*{^aei_2 zSFC?kd`er?9RUWy0w`vR|CT7{6(5_i^TglHX^Kx{Ku1XNDa1>IX!Huot_6`9`K8HP zfuw)D^_K`5oX*>`asB6(P?Lsrxgb~Y%!lU_uqP~CBq(%cXs5ZqdE+nu-e9mUS5Z%VC6A}x9q>lP{^#9BeTda&rB2q8_@cIh?=`=jl#K8erZ6DVH1 zc~Q?kfY+XN2AU9h@JnXro1JfFcXqeAyg&e_XYV&p;9py?P$hlJ2Aavx6O}t((GJ&L z)21@=dqWxzbvFttgMcflnbK78ek_=)A|ri9+on@Hq}7_+He3X*Hkk80A@<{8evOc? z93iCw9CO@{0wdT-mcw=m(2+T?OG1j|V0{S_qel8;FO)2Tc|qVxCOpjoRAqsZ&(f4= zDnv~J8^{(|nQW4JuK7~VT|L*WdcOHkwp!PZ=Wvr9NRMorY!v5zoNfEtADgMDkj;db(hUl{u(;e|P8DN-{piiFh52Vy`hyVZp literal 0 HcmV?d00001 diff --git a/test/bytecode_graal311/03_double_star_unpack.graalpy311.pyc b/test/bytecode_graal311/03_double_star_unpack.graalpy311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..8ed9986bd76aad7ca254a7db87326fe9bb5f4d6c GIT binary patch literal 866 zcmcgq%TC)+5S{CL6VfJ89==k%AsPiqHyWYyG{_ zLR(sDWs@yF9@}E;c!Qq&KiX=Yz<<)VY@I$=vq*i6u~Uby16j=%gk-y_d@Ga6&-^LL zocdKOsp}fC{gw_($5xjPu^m_>mAKOdb)zflyXLJmmnm+)trpeKDzRmO1_v5-^|e84 zIF=lbm&`aF;>F#l7xNb(7q<>>9`i5oIntNK$DX;?tO)rEvq?>{KuwD&7pPw2(6lIc z(_BH^yeNt5@~uWYfYJYqh3q1i0fEg-;E5&xui!8-v^ZxhQF6~f3O;rN0epY>c_wnD oM~z<-IrL@y=Y3RSgRGm~8BhU~nGGiXoc{+*!=9LkCpH8g0C;AAS^xk5 literal 0 HcmV?d00001 diff --git a/test/bytecode_graal311/03_else_removal.graalpy311.pyc b/test/bytecode_graal311/03_else_removal.graalpy311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..071201a55019e5d0db44318e0a1ee44e28fb3127 GIT binary patch literal 570 zcmZWl%TB^T6rE{#`5@84!Wc1e!@>l|1QIvu2e4oPiQ5Ls1RDFwbV^{^{+J8>1wX^3 z3m2x|1C*eiHwhBl3YbO4IKj1GI z4qntZ#v+%1~Q-tb2n?Mj-Yq?Hr3?p-5;Fdbz>sblwU zDwAnCidAdkg+``iQfb0*64AiKnRZDIv!K&Hl82oES}2b^M+fa>YSn~zDGAXm^N5pi z>}3(1E^D?ISYx%z)e~Jt)PL%gdMo|>+FEUhZv7a$*0w!s*j0PBW7q8bUF233m9HF> ze^!MH#szr3u({%d6w@!jpW}d@W4xv`)9OoJT%9?Fo|{Fo;Ps_Ef)>}Fs3VZN`5vnUFywNv kVu9`e&R4l`69$&wfb+qC1ulH>-!y*3|G;k10gTH4pO}Yl3;+NC literal 0 HcmV?d00001 diff --git a/test/bytecode_graal311/03_fn_defaults.graalpy311.pyc b/test/bytecode_graal311/03_fn_defaults.graalpy311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..4643a05bdd6c4f5e654b91ad40c1e7a418293c98 GIT binary patch literal 1297 zcmb_c&2G~`5T3P78bX08vQ#d80i?3Dv3f$h0UQ!>ww!p=T6JQ_KPBlcJOEcDUWF6w zof{9p331`h3FeD;9S0u}h)>>pGv3+RZ)YcdJi6Z_#)q4?)Axet_7yua&n8kW3zf}- z`1op)%k!wXD918OCYLLju8NCfe!L8$Tox)XWFF1ZSowKUW)mgH<@w-DJ{|bexgV-& zP{u|6Bwg7DMDHA;qb~38Y?g#&te!V*$S|TsSXs#RHSRfxmbs)DyDm;76! zB@Q(JaL9%@y(tK)4A<&RnFl%$DYokD|D~?8$xF1y{1@sx(*)*pJL;UaI>g~5t=eH? zQU0NZ_~!sWX)IbH_1jkPdf+w(u&wPKP?C+6aTqtqn6|Mw(f$jMbHj ybKK^lj8wr~qjmQW^wdLUe0i#lG!jfl!iQ`fyrC+R$gITo;opJPW(P2Y0>1#}9=`Vg literal 0 HcmV?d00001 diff --git a/test/bytecode_graal311/03_ifelse.graalpy311.pyc b/test/bytecode_graal311/03_ifelse.graalpy311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..313272cdadf5f3ff2b9feea6aaa4c149b3e3acb9 GIT binary patch literal 2405 zcma)8OK;mo5T513dRdN5Nsi-Gbd#b*Ti2FdyEjLNx;@AVlvFtv1Wm1M)e@<6@o|e){40w-4u-KH^C& z@SU1G4W;key^W_%P&?{|$HT*#?>Q%DwZU0|`!tsSe|k-b1}4$jm?qCc}lRYuzDd+lLQ)@ONmkb+=ljj=^krh$0;V@rs#Xem@y zS}K**mPTc5*Qi53*0+K2{FZngYekx1T%cHO0OJggE5JBU@mysV;g!yZXpDWk>z0`g zY(J1z-}X;r+X|!;c0D)4a?7&awq-3PY}XA!+jXRKES(d}%0U=}{vho3CG*z+2F|Og ziCLPesmy%AXwris#wV1$Co;umNg-1)g{dynve;MXpu|&kSy{dk?Hc!ZW2|H}x|!2- z@lU3pzFc?_tJ_hQr>aVMT6(og{EHQqsFb5cBa!~{2_-*R2Xg5t2;1H;1a~;>bfgd8 zS=M#oHqiEu0+gqNNoVLf*cqG!JWfGjuK5yL8>uYajyaOG&4`Foz!pMk-vw|O00*FR zVF|5tW5RO|X~Y0M(DUls>iRZ$YJm?(qQ1@4RGZ60PsEyLj;o@5q-6I64f4iaUXC(z zm$7mynisD{lvUJBR;c1qdsVz#qNS*yT;z}`0CI|WJ1!jWqPKke`?ek0$h$8Go*!c6 zJH{zM&`f98&7GS7LO{T9ah$-^PO_X1Fv>7W^spZX0+2ZHu#IFv5#d9IwQ&MxF2D>s zYYBTkU|c0`SY=AO2CU#HoveH^lp4k5sPL5;!vG;sI*`ubxqw-*m zUr*7T)5tY;4HPiSWcZ4%MDr>wX0tD%m8hg&%yYOb7y~H!I~X2@X9J0DVbuEge@*4^*^Ox`a$Mwt+<{I9+I@4^_?#7^O5u-K=Wn83(Q&xQneC7)Dc2(Kx$nn6}x3f(Qz485Qr4fC7&jUA2d{lXg0={%$wrMLcc(RiEkYtj1hc<5FtT` zm^Z-0kT0Wz)&Kkn*y>{fmr@-`hqcYbkyKl;ybE}Z@)G~#|236DqqNy@fG2uDGr&V8 zbeH+K)Q>nHm->kFvr?aM?w9(M^M(Ou^o^b1i`qWZV8R#vsN-~l>O1f84E*ua)qr8O I1Q|BKAHn%|n*aa+ literal 0 HcmV?d00001 diff --git a/test/bytecode_graal311/04_withas.graalpy311.pyc b/test/bytecode_graal311/04_withas.graalpy311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..85c8550f020c072e1d01b892041e5aa24f332db2 GIT binary patch literal 2063 zcmah}O>f&q5Z&d6EPp7G2v&w&SV{{QEdnIWfrlP~9^w{lQ6MPPQ+p9;X-yH4NSRAJ z){#8rH}voHH{@^RR3IqS#(j?z1-Xvhksfz;c6Vm>?d(4OrL`j<2fwz5Z!97H_!%8f zrz1~YWh#w>>66Qm_QEKeT%3AoGJ3V}=8J5S#80lqk@hmBGfzje`BV*ca*>Xdr?Xk6 zy=VULH5LW>>3m_fh4_6-h@&Q)Kc6Mzi>dl%Q)dRXNGP8I10h^7kiwM%L%7Dk6s|e2 zglqZE*PL4z`$S=j!t4^o7QQW_)LdvTHEVAZ%*Dp?7I2oNvmkq|)T?o@APrT{KOKP0Rg*Y{_2XHZ^EEcr1?E_5gKT=KQz%_(DdL`(Pwzo$&$-dcR=vo?3 z9s@lDJCrYED0;GIoQR%zB2J9(d!ujl?Q?l9wi*JYfR-OH8?=aHr}OT3Sr{k{qno!H zTT+-d@Mn9OcMlp;nlf)oTP_;{zv8-?cSYU>i>oDE#(bGSHydcJ(rge!TImk@zo|6& zHoA;7>fyUIO;V;>(@Q-@U8pg)9q@C?&lNulU@bJ1gfqrAKvKU17?(PanV@U79IMBn zt`ES0-UZ0ky<(Qfu$sa|E8)7&0LJYDM*z>N-WC%*0BnFduV{6a_g|I!N9m~+>JI?l zL8Xgx+2@Hmk6_6y98tb4mw8L%t$a`ZErrd3XBYpv!s&sy0@gyqx}=%??g}4}K4+0N z3U|kg$Q&x!^jn&FZRn4raP!nDY&ljDa_e=tWvJJ2Ef4k+peJ^JZ1?3M_U=!9+5sN; z&QlEJE&F|8;5jo~OXe-G;EKEd%$e?qfQQK~mv0m;8L$=_*39q@k{LXY>jGg7P#yt% z;g}|*rlsof%Q)3=T^^i6HaNmK1jj0d?s_iovTr^K^vrpD4y~Si3Et1~4EU3|?R*Y9 z>!dI`J2Kyu|KuH9^0Hb!;9_?Qb65V=tn;sPEpKJOmu{khu}U?=O@laO(jULAoIy8a zi{LhiV}SA%z#Gj(OW~8T!5l*iRv#xYa?KA*g*uOdTyY|U(K!QhoOU#8;n7j*puC#@ NBlYd&G`eF*%D;2GLwf)K literal 0 HcmV?d00001 diff --git a/test/bytecode_graal312/00_chained-compare.graalpy312.pyc b/test/bytecode_graal312/00_chained-compare.graalpy312.pyc new file mode 100644 index 0000000000000000000000000000000000000000..0114fd05a0790cd45316ede02b73c6384307b77d GIT binary patch literal 456 zcmbtP%SyvQ6upy#rZyF;$x@+ig*X905Y&aP6cIs$x+>{pXo7i>OtjgVZ`0rKAKa)Q ziryPq(Y5Dr&Kxe>$823L_W*If{unBJAFk1OSqLs?N*1XfySJj`(@2HYgcq5(sd-+j zFiYK85S3iXQt>iM@>q_`tSW@$lWMx-anBoz(2r6XxFSn(zmVH`tq%ZB8Nk&>7uW13 zSy09D@OQ@Y4|Gg>sL`eM^pd+ literal 0 HcmV?d00001 diff --git a/test/bytecode_graal312/01_chained_compare.graalpy312.pyc b/test/bytecode_graal312/01_chained_compare.graalpy312.pyc new file mode 100644 index 0000000000000000000000000000000000000000..0ab104add344872c62da9f3f6c94ceacf19ef583 GIT binary patch literal 1610 zcmb_cK~K~`6n-=9(z?JdbQ=r=mPJA|M5xAy7m&ncFNzxy(ZtiH+pVy&(6zf2IBEBf z_+z|!^{8i~iN+XW5D?$jZOKA<^qahyH?MEroA=F3=bsE`iSaD^?!`k%^!_UcXX+jkdR2g(T1hYZovDV@_S?|Ai~>E7?xv6lo2E2}IUL?&$r zGR1}@Qx+&t%7QXH>O8LHYX!x=!hRWNO{o{etANUq3Nlb0C^Kbg*ofDaE0C^AUB!fS zGkw~qA-^ax(pR0=Z2k}=P2 zp(akd(hP^PIpt@GqBfTO8f&Ma85YEm&aCMO3?LacX~W>vUUGj9*emgF-l7V|o8;>N zD|i{e5DO~CPSfaNb3YLBEOJh=<13;^UwBNX%SpSQPQ1Y=0nTxeWrB$+i@`^8)3V5F zQR+f7Rn0MQvF8iZ$>! zq-!ygJubl&C~UgB7$Qp1)zLLr&H+OunPJ1Zc!KJ{A_|CsP(Xi;JH$;LBez1LNV3y>;bGph>iiHQ7VYwL#d=VjeD-*1bv*1_yAAm5}6hdJ{ GI^ZA5r~Li^ literal 0 HcmV?d00001 diff --git a/test/bytecode_graal312/01_comprehension.graalpy312.pyc b/test/bytecode_graal312/01_comprehension.graalpy312.pyc new file mode 100644 index 0000000000000000000000000000000000000000..1abc5589eedd649da1c2557075cd256ce93e4d52 GIT binary patch literal 1253 zcmbVMTWb?R6rS1L+*-UesrF)%EUA}nRA(QW;Tyr-CAIT4;!DlKWYB>h6YE)o+Hn+ zj6*l54n5_Z__{l2J8|Tlo;&?>-HpQPS;tq7mP$Ly@AU&IR5XY^>9hwYJ9Vf2Sa?yd zAIq)`l^=z*{<(RVG2deBbvaK-n!Ttq2;}apOzJ62lGccOtkFu2xV6km{K#M>WAR|0 zFPn|x7EBXsp=y1m5fYf>7OafDlK*Nm``6a@9ILZB5>sB5BMK49_d;OV@jZ>~LcH_o z_~LrIy|W$5A!+A;!(3)*h@~FH;YE2S)QpIzDd2LOc*I%7Twzby;sI+EZPJXa#Au9G z3v7ukC1Whugo$ZoSr(q0m?8RF_7uWG=>-b9p&JY>n`sDv%JmJ*oPxCrO^dAnC2;nQYt#s^qx+m#Hc7#Z+5C`!P2~iqEoA@ulhhP)O1T2vc#6v+?$oOKg zPtz3G1JF0@}FQY5Vt@o(@~zyKYE5oRO?egh!n!chPK literal 0 HcmV?d00001 diff --git a/test/bytecode_graal312/01_if_try_except.graalpy312.pyc b/test/bytecode_graal312/01_if_try_except.graalpy312.pyc new file mode 100644 index 0000000000000000000000000000000000000000..138c9f5eb6bb6bc136fb5724805404990d2fac4d GIT binary patch literal 904 zcmZ`%O>5gg5FN>qtvGV6B*urdv3+O=4Na9`8t4Z(6nbb0ZJ;fsrzMs*j;L)JNfy>| z_1F3v`cDca(9q6v*G2^L#Pht_eLFiE`S4StPK@_Ey>Dj*(T}g3_(>f2a*@h-dO1GI zg2W$%>Ggcz$5HS-_h)%}9ZioG!!YqvnWTOaPG(~%l4u?W(jUx6{l0&EBEldk$andJ+xiV|iBA=wt;aHTlc+2e2w%{tN=D5}`@3z=%E2pTpm1q1h$R=AgYd6XxR9SS0R5NfpNb3_%@EC z7_$H;%r&s^0U3skzXjrQ@Eo_8k2GQIFdu7jpnc{OP3%{hXaGPBmx<{yP>O*T??SIF zgVqnVe{DzgWht8@66~NnG}`WIjTR5IMte`SKIGWf`h??it+Dn>>lYmVGM1OI#$C9h a$3#ukf)^eRYutTh%)A7ot0Rc3^8Wzu(t;)c literal 0 HcmV?d00001 diff --git a/test/bytecode_graal312/01_try_else.graalpy312.pyc b/test/bytecode_graal312/01_try_else.graalpy312.pyc new file mode 100644 index 0000000000000000000000000000000000000000..d7b5e331fa734582c6dbb04cf5ff96751f0527b0 GIT binary patch literal 856 zcmah{U2D@&7=BNhHl?-chtthU+A`RUvSn4+l_-e4vh%_zC=5zJ4qGv8Le5EPE)(#V z`5V0S!k-|xL2;n(1I^aKz$ZL8?|I+noV*`-a#AS~7yLcxA(kpRXBF#Qp<2Y z^!68H<(^ITc{FlEfBYqOgIJ&Y^Zn&ys$4CVcGYwicygfpC>%?76rDZqx`*9?4&#CJ zlspLHT#e|bLG;ln^8GJn{v`6`%S{_eWMCoj0s26+Mfd5o*z1WcanyJSL0V~mX|+_a zYO9?~i*{)j_v2K7iIk?=Vk?v?^0Z>>79jlY+(>UMv7yVe{ffB|ZSkqoHd<7E+imCa zO={(O?CWojnqpXIMa$SWBJoDhxNlFeX<^ehj@_2g_{@UTEQ%|U*v6%m)bhX6ffgc5FI;q;-(HUZInZyNe)yM6~$B$mH1E(NE|>FR00m1R*kcy7D*i0juju* ze~sV3KS4s3s9>JiL{_Cf>t){TzMUP9bM&dzB*y#Q!Phf`=*MSH{3H&1xk_a`znmUt zLE=xs^lCZs<0$x^`-?oiisr|wahUk2Oj17yXN##6Nwkau>5rC^;n06}BGNb)auvu$ z`gD=kJR-M7^kv`S8(z<%@p3B9sv2#q!JSZp$=!75bcfFp75CgKQ4qFWrkKc7Bzcm` znaE_EgwY%)s(|(9{vGB!maFHvb$Y|xqtizJ;w6!t*?l^1kM@kqEtAvW{9tTnO~S6sD|TOzr34byQ`d{*;StL#~_<*)oxrXkCdlei^``k z-J;f29g_`psu$*eWpS?B#+LQFMXejPHWcQzaqXa4?ujs7A-;wDaRkQs?&I4yj$+IL zoG~}R!Utp+HvSWc<={EqXFk+~vB!L*$$<`-k2SGhXQBZBHC!g9$3Q6tTD%RtRtBvf zX#d8J>SZaLBNFVOJT%%KXpI&RwMKhSv_9fE)cS#AsC667_3}?muA_zcdT04rR~TTJE9tR9p4g0y>q*rGEQD&EzYP!Fq{fLxBVydbBlJqN0*+`z5>d&dPKnoWubnS`cxlE>1On)s=>CfiH zRwS!wN`K_dpmof?D%_ysi>faI&p8#18TJKy4U&oDs16SIeBbj^tnx8aAe<(2+iiM* z#)?yGH2mt&Otaano!Cwf5yKBGN03>2b(WuIv3)FD(QW%XciFgh%H?gxvuaMTQy#^Q z9~|=BU>0a!)1@cWY>_!#$t|*rxK&;GwlZLuJR9&cuna7(p?%S{_&oyh|6Jym*>OUf zFZ?P8h&JwAu(kUB!zhpy)Lx3^ZY(cn%El#7XD~n@W`^XKp1~lI>>`XCBbCrZ4il?Xoz4;Of)9AL?b8T$)k7y6K@1+fhtnc79&USbNmeb1wX`- zi5GpZrHv9j;Dfg_`(|gSGrM11G6WcHzI5JUpQ~7u=bFlT@GZC3=oaryPql5oGiWN; zF>i;eKlD3JulR6nd&;*wUwQUjziZV!XW*KaY7W{*$EtK#Z+OF=S#LS+L4TOciaaGn zF7pd0aB}Bd54zUrcOP;L4PF|oiL6OYlQpfpl4Eq7NR#7~jOQ}n$@>#Hz|02fNXv1s z{s7~z`QSvba36swtWeN0`f}MeTAhl1qgPT}GFQo-CvVFuB}7N7+S@2CfBy|_w4h7; zdz@S!eOZ%r&50No3K#U)ZVFrk*FmPxr%rNDi$3Ex+@N7vHo$l=CJMhIY?)_1fp8bz z!F#E_=6MsQH!=Lc2$afTL8gYJg+uyF&&e(xuz}231~}7ML;o-Yzeg0|C+pyu)3ewj z_g7qOFb0KS@*8kwoqPc~+n@qjg8t5g+|%C!qc~id=K}DRG9V}UKZNhb{OA?g3{}1& V>r#h_!8j4srkw`0D33PE`2tN}eop`Z literal 0 HcmV?d00001 diff --git a/test/bytecode_graal312/02_async_for_generator.graalpy312.pyc b/test/bytecode_graal312/02_async_for_generator.graalpy312.pyc new file mode 100644 index 0000000000000000000000000000000000000000..d78f8ec6baab09c7d40eecdf21b7f9bd3cf3425a GIT binary patch literal 2019 zcmah~%Wl&^6rFM12MuXy8X%?QLE8<8#1%+o6J^;A3JY2U8ydN(^B@mLc2b&U%O|kp zXOQ@Y>{+p3fk0wY3CWz}cw8qf6-2Qan&{I&3OH=z`hVk zu`fkZ?rS2c?IbevIMX(XGhLi!@nf40e_Ut=PBEZkwycWjnBBU?A!pF#f@mu3rrSq% zLg+F|PtBWBNlb}`4&#AeMl9_nZlZst#Zq_V_moJTXBm&eIYgI=5>9?GO5Z?JWS&lX zPKld~P%aePcGYaVr9$WtU7q1{Kt|}xJI%#fqpZKv%X3+ok;mG+UavJod9AgRcnlu_ zLetNR{3&($XV#mttdbgp4N=(Us!iaMaL2O%vycYp&OVbyP-nXgC_B3T9FBADCXfRz z$&7!D;V@%)UJmcu0JT+sMdCrmR?mYPipsxQh0K)riR1t$Q(-$wa|+5MXndz&1{X*I z!C}WE8BeTZ{4|zK$RA1gOg-o8AA%4JM|1++Zx|PKz^}2$qO97TUg<70(1;X3Xo_;u z;l{P!GKEI{7Z2w9Ascresd_SA{f&IGUqSzm-o4hd4!Vm!F3#P_F>i%?-Z@^2`0Nic-! zk4cRKv7Z87iaoh67w(DJ?nF&+kEgK>foEC%@>}*Vp7V#S3$?2r<8eDZv*~cKrYtom zp&Pv}Rm*)0DvJLr8GZ{}088e1HY*>9rODev%V-CisGM?od~x`U=k+!DHNsu(VqJcd zUO29*h$TRxh3)8u{0n4aQ*iNxC%6RgWOD##vCo4csIz6da{zS;=kXR{n+LW43fI3* z0z2L30CHkTo;^*9BW>IUbuLXi8s8WHG5+<#D~NUqsZbOh&iR)x?nP8;D!OmLOKn0$ OV?wT!==Z=Niq2n-?f_K) literal 0 HcmV?d00001 diff --git a/test/bytecode_graal312/02_call_ex_kw.graalpy312.pyc b/test/bytecode_graal312/02_call_ex_kw.graalpy312.pyc new file mode 100644 index 0000000000000000000000000000000000000000..1d390f021a632652686876960b86a69bd25a3221 GIT binary patch literal 2581 zcmd5;%WoS+7@ygPAG=P{+S{ZovW24L5L&Z&DF>)nB{YIlg;XPjBH=pDHgV&Zc0EnP ziM99xIB?{E_)B<5AdVa&PC?>8B@iHxYD6HSe7}iz?K~P#PyDj;J!WQSzTeEZpY#0f z5rYvPUUlDoC(YRBC32j=uR7jt$Mc(&dhtOua5ih5EwS$St?Krk)86ZBwVK7tDdtiHW!wh+4*v{Qm>c2-SYO%3++Ai5@R3I25;n3w8M=?YeUq% zmxpbH5g|*)2h=DUie#brvqt(@p2O&c6-qMgBK8 zl)tpELYswlhCd4JEdM36pXJ|&_6+|fv>pC+Xurt62<^~Rx{qmAm_62H#t$xKl-M8z zg00q0yW&?G0VnUC0x>7$yp#**u0X6qR3SD@Sgm^9t9ELwW`K2?m4>&`5tI-*d9Sx> z%?_rvF}2+aTFv@iIS>uxIP%>le8qu0nl?qUndbiY!r_?rPaF);O3PfqSdv*STBkh%cn zG;^pSoHM{81dKf^)L>l_?k3I@Ro-Z4K|{q&JZ z6uo*bL*?lh#+M128~>T+N)!t;vL6_ub^*=)Jw`kS_b7QDe<1U6p}rXK6g<93_H;a> zyS*S!2bcKDa1>EaqMTm94jae|#@)dgy2Ay@P=5TF1%N#jj((OF_?=G*3Q`oObDW}+ zW7=<%6UGlz+74%Mv=N0tk-;M9t>UEc?LGPaFzpt#7*^l9Lb^x|!JG!xCtwI{;6nEj zWXLi%*8{WlzM4O%VHJpELs9-XVi@j5Fu?Qh(?M=|yUY?g_xU1k5;btXQ)qtH^yR*M0Oz)01*j$}K6k z)|awLQsKD9=nwpXsN|jgJ;J6QgsiPwGAfAs5StL&)MB9H uL}uOW53Q26sr945c0)if*rOYIXej0O|OXJ3PetbTMvkUkXocl2t|&)BvupKTCdai1nUQZ zXF-IX)X``r5lq=OR6z4-Vk;3)SF9`X5uBTYN0@Pe|(e>Y|>wJ8b3ebDZ`Ys(24epKZ zlY0}kH)zqW!9H(L^ZT7=?9*mmZ)?k<=H=0w&82RUZfVOTKHAhAHmR|G&;TpJiydc) z60@U4py0)YKBl3kf+#ducjY)~usl15#!3a$zk!7k7?2=Ye{_BAk2j9lUwwbR)Hi}&7zr>Fq(^w&Z<;@}~SX6+&TGOr8R>)pbChb6XI<{%%BgE;&w UDwOTYN$?9_2l&fc$nx8N00_dO4gdfE literal 0 HcmV?d00001 diff --git a/test/bytecode_graal312/02_tryfinally_return.graalpy312.pyc b/test/bytecode_graal312/02_tryfinally_return.graalpy312.pyc new file mode 100644 index 0000000000000000000000000000000000000000..67de16a1438f3a3359f4245e7ff3cee70a2e375a GIT binary patch literal 546 zcmZus!A^rf5FJXX#8jfhYh&Wkq^{9~lj#>2FY2iWBCu_V6v(nvIJTeSuk_}Hc&10B)oc<}1-9c`n~2+Vq_+VTd-9Im_Pj(RU zn8F6HL*vIFi>yu09?;PTM*w5M3P}qTo{`{rNbnR8KyBC%8h~Yh0n=e( lvHimkTkM;mU^Wu)m(jW)LPL$i0mts`CQSp<_6lNa_Xm4M5?ei z+B)@P_asP$>9MOK|I5^!Op{?0Zk_dm*iB@dxN$I^jHDMwsq&?JoSy9MxI53iuft#@ zcfDY6!?q_=y-swl5q(^@xX-I`)K5q9^&-bGC0Ix=*izBmBwC?vQv-J@;D$j5){1y4 z4xIy|@S7cKf670I%6+Zvyybg_nCE6QGp(!KXl6Bz^j3D)y2@6w`cmdp=MM3cYqf&q zI^|m9LFGH2V2g&ib*_j>J#WB!d0v(IyEIIKv3#Rcq-^{)>8V)q(HnF07qHCC;6uqI zRpGbwTl!leM%`C7PCkNS|}Z;Xr9GltkPUgMWFOttKjU}_-h!&;;D$0IL(%= zF41|5=wpAICp@30vpg0r)^)%z#7JnL`6UfMl^2$?cdOaXo;CDOkyg6iW9JvY(7@#m zm0RAK^OIj_>x}8>iCsrgCSJvnNOYU6aW;`ku(Cl6lzt;Dh0bMi-QO(Sw5+vK=sb&Z zYs5)c_7m%!cSJ+~5&H_yT9vKcqGSEB$Sv({w{Y6j#w-xE=LU^`;eJ;9S{xdk#ARf zJ9I!ty!YGofyHt#^p82K+TQIIJI>$I=@q`UDh`YN&dMkLmA3D#y3}nB0z@6=4|$@a zxp*yQDzW36WF{7s1th>#e|4~wo@n8)qQgkRaVgV0gJT*_B#VZCyg4PB+`A1uWQj3Y y3rR%xtGCuGb?vE-aZ{(88zR1bU$jO!w!vLd1j(Wy^M9G~`1Jozh?)+N2HZdSe3$Y7 literal 0 HcmV?d00001 diff --git a/test/bytecode_graal312/03_async_await.graalpy312.pyc b/test/bytecode_graal312/03_async_await.graalpy312.pyc new file mode 100644 index 0000000000000000000000000000000000000000..7765121830f8aff59d2194327a1023ae3767d481 GIT binary patch literal 2819 zcmb`JO>Y}T7{_PVYsWZsk~%IFhr~${2#|s+MfiXa2cSqGQUP@joGi!LBump>Yu9cP zZo4`0x%dn{az|Vc2M$C?;rY$(Y`t+@wa~xw_ssJ$GtbNJI3GNy*OcJv)y*G%x0L$j zp$MHQ9CqB(u^ak>~M>x|CEM}fb6y6;7uu^Wv$k@t9X?DnHz z5)R$Y-sEuSqt4x({vbN@hyB6Hz#D%!IxDRx^|PGyaJ?!=eDXNhpB%fNPS1(MKtfUP z2zyF3RnJmQt7ogG-7BePspqJs(<`fHxmQumO1JSPs}g$|CXPxaxM z0;_(Zce2pLF2 z_u308G7a6qz8f+-2|am+WRin??jzB6Dkb&S#PGK8-Hax2P6v*VC@8>7fdB=pyA&X@ zH+)^l{>*O+u|HieG`k>(OAhwg5PoKDEji0mooI`?ZSAgpQ+m{G?1)EVuP*!<*VX*L znib!${;^cqe9p6DOmH3%o@PotV7dRRXR<+L4sHm|BfKVaY&=v{8zM8_6dJos6%7NV zjGgSRLHn7Goi4TCEtwJHDjES6fR1w*A%1C60``Q3iv)$P4DB@cH*XvUz#9zKg*=v= zKLhQI#bop>i$iSs%d8>`GA(A&;QEMf&gAg-(*KL!+*g~jeM88}SD>RewMQWOX&=+| UO;NH3{~^9Ga5ft<>eEE`FLV`Q0ssI2 literal 0 HcmV?d00001 diff --git a/test/bytecode_graal312/03_double_star_unpack.graalpy312.pyc b/test/bytecode_graal312/03_double_star_unpack.graalpy312.pyc new file mode 100644 index 0000000000000000000000000000000000000000..756555a0adf4912495c1cf11df4ff75fb0b49189 GIT binary patch literal 867 zcmcgq%TC)s6usk_gtSSNhewJx#?8gmLC)2==+Dg_k!s34GWXRfe9yR z7?1qH%DW&jy?(lHJ0^~TgQ*!$)BR|)GU@gclZHuZlKyZ!2-`_y;~+F0+gsl-YwPW9 zWIG6_e%!XBu^$|)j;FFpbm0)aS}yRU&0*BFgYfC1k99IAcHS~y5^35J&#bVHm96J5 zlos02QY)8S@%q>md&k>!@Bh(G>jeJ2c4h11|7sqoPcU}o@pUMx`GSya-zs0qr1Eor zMlz><)=KKKMr^;O$I^4vCy&?;9g<4?(gk&;E9$G}tu>b^ZojS;)sHH%Wq}3<8g=!# zL2Nje9FLdG#18S|e%wp=laP;F2e*Lv7x*CQZ27Kdp*1T)zQSx$Q!G)_Vag?{*ElpQ z3f?qV5Lb^%;<9|L(GFnrKVu=g$YnraClh$03BW6OObjh97)zAgFpz?e-9P}}AAX*R pT@=?&V3lS^0=|ZR@6zWFw2Z|J5xC?DMw86ZXB&AsCxNtmNWMHNP!5ICFDGk${RYJnH7qO9ZlnrP`>q? zh#-lkzSo(L?NCHAj6`U=fg{b(kCi3GD4ujL#Cg}0PAE+!U4J%o&VoeWW9)@iJhW=G zCiBd1Pw%^K_}yXU1Q?-_@vX4Q5>{~(69X;^^IbTZqEN+hP`1|+|L zmd^^2l2NR@_g2wZC>jdTz3hPOm<^i5e6Xdlm>K<+hvNe#nDI(laUIn|PZ8F@jzsN0l;jRc{^Bf(;0u=DD7>hs6 Y3CpfLr*MtGTkzojfFuT>0L4(?2et}as{jB1 literal 0 HcmV?d00001 diff --git a/test/bytecode_graal312/03_extendedarg.graalpy312.pyc b/test/bytecode_graal312/03_extendedarg.graalpy312.pyc new file mode 100644 index 0000000000000000000000000000000000000000..ab19a59a28ce3fe46978892ea7a6679954929b72 GIT binary patch literal 606 zcmZ`$O;5r=5M5|hlo$|+2NV8)5mqJPWF+yV7d`k94kiTJp){6l-E9?)^skxt5BvrG z1jE6LI?q@{6JIiYZ)W$+Otw20>uZA1IJxP)GCyAPM;h%&8potnFR0%;MtXicO!`uX z&h11-lXw`a`q=f2jLF2(_@gMGt_c(EknAU3v#~Gtnq9O|F1bDJHKK`C7UCr*#8s`p zGY&_gn*?;UsJT4HGOI0)wrDZ#I#2CfJKsq!t);4HRSs}!ZP?SQU9zW}cG*tfMQW80 zX@0lxlVw#fHsA$>%@IbVn0^8E87}A<#%qcbt-j>x`Ek$Cb1idbyt3ej(c;(^6}VHY zXulOv$VSHe9x%W>@B;$#E6^%)KN$>2`^v+6ka9woHQJEYp*FB7dI)?)kWLU98n~?H pz>u?f#sb{|+%Iup69&?6pz^^$37plzf8F>M{{yF42QZcaJ^`B&Z-W2; literal 0 HcmV?d00001 diff --git a/test/bytecode_graal312/03_fn_defaults.graalpy312.pyc b/test/bytecode_graal312/03_fn_defaults.graalpy312.pyc new file mode 100644 index 0000000000000000000000000000000000000000..e429d3a6480d6b669698c4e2b9c7229b0c102487 GIT binary patch literal 1298 zcmb_c!EVz)5S_J68bX08vQ#ep0i+$<;Fv{s!svArefEqnmyieKSG zd*{Xna6(+TbAoyCuH)bX0`cU{oAJ)hzMY-;>Fb9bVtlxLH-0aO?#|fp@@(YEMIp0k zm>gb>a_>AYF4WM=($VG8n=Olrbb7dm;@m4_UU+#tnI$sFQcSsn3d)uGx0 z@%K0>>!)#=9%(+-+|zt=pXY-&VR9KnamMx*kl^#dZz+zfS`1$R;p9qm5xjaJezf5O zh=V;0vy!gy)&MJC83%0AB6gRDPE)>y^OFG&T&Xe#I@aMlPgJS0nyL_ou~7wYt`_`T zp&<@60C32fIK3$dsti}^OqqK+5Ggk5?Ej^%wa!bl!~7TOPD~S+(`~79n(7dTlQe3F ziMjei4e`$b&~i1EW^+?K_~jLE_2!mi)*v133T@$+dYu-vOtldPn_C-Z#EdkPaFNI> zndG?5xr$}MT%mFIkMz`IW_)_ejx-WXN5Y3}9lWM8lE|#Y_u=1x)n*4UgaW?+Chfnn literal 0 HcmV?d00001 diff --git a/test/bytecode_graal312/03_if_try.graalpy312.pyc b/test/bytecode_graal312/03_if_try.graalpy312.pyc new file mode 100644 index 0000000000000000000000000000000000000000..303f9462d766fadae641b3a77a097feeb0aba810 GIT binary patch literal 653 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 literal 0 HcmV?d00001 diff --git a/test/bytecode_graal312/03_while_else.graalpy312.pyc b/test/bytecode_graal312/03_while_else.graalpy312.pyc new file mode 100644 index 0000000000000000000000000000000000000000..570bc3c24c2be9edc3185080e7a41879e2cd873c GIT binary patch literal 611 zcmYjN!A`D*U+6GU1nF^tCDuIP08ZxfGim2cGfd|5ao`m%@~8oRvVavF>x zUtQ%jUvI%i+F|l*j;L4TUZSK_$rA%J+d#fVo>p+>f%0bqb2f&YL@h&s#R;=X$K-Ro zb&0~3b?xew)tff0n&4vWI#gaIPMw(Xf%B6T>T$KWvZ$HxkOdC=Q?3i6*q78bV iS=(rI{4uZsHDvfu$33SlPy@0j;5T!?F>67_IN%?{0bM}= literal 0 HcmV?d00001 diff --git a/test/bytecode_graal312/04_and_del.graalpy312.pyc b/test/bytecode_graal312/04_and_del.graalpy312.pyc new file mode 100644 index 0000000000000000000000000000000000000000..bf313ad0f64d2ed898be3d34660da4b3a0945b29 GIT binary patch literal 1578 zcma)6%W4x*7(Qoal1V0MOw&ZLmx)U$v{R@TM6sxJA-1vN4G}4AGHr^vkxWaAh$J8) zg1B=bQr!6feFGOhfjch`Ai9utVTqUTn_EX${_ydC|NT$SnKOQEzz~p|#`elPRfxA& zVOX7Z*|IksyWLo-O>C4q*6Ny5U0=4^&GNl1tF`4+n~jOh%38;A?2cn~*6OXAz1V54 zx68J*yuLa;WlbGlTxwJnD|T(NwWVf-*og^oV=RI8XY0+%dd)r;<=i0<36ch`3y~Ms zrO3;ZxnTx-=`7JJh@O&2ufU&74y?j}KQw2spQ(Lmk+ z8=@#pIV?;uEA`C63jt=z#EjI_3n|4ljJb!NPtnsQQ$u(|=-E;}?nXDHt|Ts~v$`1< z3&lj}LzdLVF~x9+Qj~M2y)GKMj2JJ?(W`E66=cCc$VA^Wmx zNKMsZeWRb*?`YAW0QIh5N)zH&n*yK4YwKXL4Y>T zl(Pb%pTc4{iP{&}=W#VsMDB$~!U``QW|55iXP00DH$7VD4f)NDIWD-J8K3hzIqdU1 zH0Lqr2r%yRW6-An)}H{Tfs4L<9(o3t1z1P_WuISyp7%L@w*dCI0bB#_`t}{@+rWx% zSD=@HD!`ufw|w4!egLq~eP9cC;@gj*9|2DR*3tjm=g*+G0oJ_&UIMQH=F$Hf!WeCy zEIH>hhq3o#2k*fFi{1fN4gsbpA;FYa;`p$YqH3zS9NgW(xHy#3c8?Ua&&h5o`6C+? z^Rlt!3Lc&%hgQ|8*Qg!5p~*0U=M+2?&MO5Lv)v~SdKBPMa+#Q`P3-~J; c<67*^7=2Ko@YA6j^}*Zouh19NQL`8257HjZ#{d8T literal 0 HcmV?d00001 diff --git a/test/bytecode_graal312/04_async_stmt.graalpy312.pyc b/test/bytecode_graal312/04_async_stmt.graalpy312.pyc new file mode 100644 index 0000000000000000000000000000000000000000..c75dc27f6435e2cc061148194ba19ad3db65b187 GIT binary patch literal 684 zcmb7B%}&BV5FVf)kQNLYNgDCs#YBT^f^ss(gTxDX@aIfQS!lJiWOu7@v-oKG3O<1^ zVYui_!%q)h{5D_b=i8Z`?jGJ5ML@jnemGxf-|z9mq_7#EC@y@-tQQU&XYAy(Yssl^ccmJs>gC%3XG;(95@~AQS0QOUGAAFt3ayVF7(axL8_f@RxU9SX|t>ul{7HGm~X)!E7Fbc zNQX#|@*2czmM-b@3dHLTd(hGGP|6X(i-FNK_qniCAX*bw>6o|;edUgLONc=O3Upam^2c0CCivpH2YcC3E%of&5y>gNsRvJ2TIj44eJZv?X}Q^}5pL zlToWT=i|B89Suvfwkx>j2#*VQFz!1IF_M#(!)@6qm-+ccqbWO$rVwstcs8D^8GwQU z@Q^pKLuD{(%f55Ht1-NVimHMpV;0;%!D4j=mLi!6@%`EXfT@^l3dSwdp|+<$=-lmV zV1i_EWPj>$*^`5L82q6oOKtCP~y;H2VGjf%e%# f3Fq3nk)UrJp;5m>w3CfKMn2tWibb;!Q!e2by2)lT literal 0 HcmV?d00001 diff --git a/test/bytecode_graal312/04_for_no_jump_back.graalpy312.pyc b/test/bytecode_graal312/04_for_no_jump_back.graalpy312.pyc new file mode 100644 index 0000000000000000000000000000000000000000..bd75fa24fa400a0667614e9570cbba37a2baa551 GIT binary patch literal 766 zcmaJ;O;6iE5Zz7e;5H70B)t?8khmd*t(2@ZR0!>*C`l?@%RPth{4076je3!hRD6aqW&b$2Uhe(N*6aG$ ztLRn$Z(1R1v+CE@Qn}5y=>tZUCH~EAm$n@$8&6w)5-p}-^9otMwa%A;^X=k{;v-P`QDlV@`7D`B zhBp(?9Dnk_3Z5V24pPSM^XnLdzRmQ28Mgkf}{{R30 literal 0 HcmV?d00001 diff --git a/test/bytecode_graal312/04_grammar.graalpy312.pyc b/test/bytecode_graal312/04_grammar.graalpy312.pyc new file mode 100644 index 0000000000000000000000000000000000000000..eae6b2b163b5f9935031933219dea29f207a2377 GIT binary patch literal 5306 zcmdT|TTdHD6h3Pk42IaoHV{l49Q6Wj0EbYKiYDYr)rSPB3T+})DmBa6IPnGf(!%5V zZ}hp3`4#;QytO~UPnD%MYDB+p_JS8X36Mrr&g#sWIWs%+oipdmto_;J3n2kL`T3V0 zehrHJ_6-`@dQHz7`wgR3$(0s<((Bnmv9a6S&ep2>^MmZ(L1VXCS=iqx*0T+x-pJOA z<-L-zRj)Q{x{=*(7M5>huYJB%sO8G#Ty1ghz#kQPkP!JcHH7JJma99>lCjoZCkBT! zR4#!xMG~^9NkWTj>uCBU;fwp$CE;I*UE|=^K$P4HO6$Qja_cJz$*7FB0@Cs&$Swci zkc3|PB`Q&(2;j9CSl>1D=UerIN+Y+wWz=fb8r?u^whoF$X@}SfMrAACtmuBLj?zO^ zAEx?G)?Z7*93qez@IX>7%WdtpZ{05s$F`GNZUkC=C8j_0?^t%4ftEjP4h4sXMyshrpxatcq;%0^+gTl`uz+!;KAd4W2Ar`|dLMW1Qdt_as7=_rpKz-QKM=X7m z`Z4NbEaEH@)`)Ry#Dpa#EpgEjQ2_AKCMq-SWm$Ho!VtBD zA3fvkjAS@OjqM(y&>Ro7(0E?C*q)bp_gz*lx39}}OcIL++tV^l)o42{X{Cy{XJwYE zsrG^_D3zK)FbgAvyZ!piVQ&HK(q+^(4pT}$j{0%-F5WCv^<1gGw&;0*YcQ^p($w<1 zO>Nx=-^ZaahqPhsWl(}4?av4T8P77*oSB>ldx*-7Zp|nf%n!~!X-fz%v6I0}trgT~ zgH9Wh^7PK=N->n*eH3^Wcr>WOCxs4}5cVN!Jc9#DUL&cvGhN~ z(CdGqRvR$cvjMPROvX-U!RvM*jRo0v1^iS)oPfT$r`_#JfWXTTLP9-` z6(`rGQ#Sr6Qg9A(H+_r-;eP@qzU~b{Q?-eib;`5s2iM}Et}q`5j{*(Xhb8QQc9403 z=Pk%*F*A|Rftl1?$t6yBL=7>k24si(vt#7bg}KaXT77G$^R;R@J(rnJFLfB3Zts5j zR?mpD*iP^~@0uDj=jlBJp?%1PtmNrBWHGFVh}n}li%`(qEciW~ulzpY{n^yK*`tu# zmwco*fx0evyxc>s6-3_eeqVx~eb>RxIfiO~I(ff$c!Ib)wlr^V*phdjUA?{4=h?;o z_Nu%A*fjbJ@O#?I_w%W_Y6JfglJ_T9>7ftxQ}Y%q;jXNK&m4+p2`Z)8^{QfyUxH~*j^-`{0Pv@)ERU1i%h)-(m>AFDXRxRim+y#4>0x!A5Wk@`M`FGC? zHa;Zc!K+Yn$5aDt{>EVN@s4Mf^1i39=>IF=Pr+BgwD>;wYw-8rAHfFr8JP1Os=v~l zzoIvrgi;E(6l}x|B8O(zTvI#ea{WJY4?8z$z#*mBwKB3 b2#^{_I=wWU^aM;t(CD`j$2jv)I*$AoLdNpR literal 0 HcmV?d00001 diff --git a/test/bytecode_graal312/04_importlist.graalpy312.pyc b/test/bytecode_graal312/04_importlist.graalpy312.pyc new file mode 100644 index 0000000000000000000000000000000000000000..ee3509e31c90c7608d30e473f26f07144692de7b GIT binary patch literal 581 zcmbtQOHRWu5Ovzp77zkKKrHA5Xj&ujSs=uY69m>(>Y66PiLKZ{%`zN}4J^4r&jRyW zg|=*YqtUz>kLHc%Jlxx1gzD@we)kyrc%+2eTyQyaGS4D4comjU6Bid_o@?<^a#Olk zXM@=!vD``PxJ^={E$)QxEfJa=T0To4NciRVC;(oo_bwUxJ&h#;ryJih_z^_xMkzs(-IIefsV9%@SoBz<_y((mbTwv2}@g2$4S$Xsv;Tfg^J0;GX{jCVUex1raL&KcN(2 AQvd(} literal 0 HcmV?d00001 diff --git a/test/bytecode_graal312/04_lambda_star_default.graalpy312.pyc b/test/bytecode_graal312/04_lambda_star_default.graalpy312.pyc new file mode 100644 index 0000000000000000000000000000000000000000..41cbce26464dd49175abfab254a354700b73c488 GIT binary patch literal 966 zcma)4y>8P`6h2O3+R_FQH=+?DVPJ`nnp-IpF+`EDfFTGLf|Lb{#r3a+*v;6xauI5zgf_INUyQyjVy#mLm3Mq3@34Ac<^OOp^U>SM1yy`_^pY zSmRh)(b#eKti+d{a9+Mn^r%eqvboBwdb7Yue79eeF^@utg&Nb4s7^zT%+ka4Cw1+< zaRU)&4gTMjSIq}&pG-0@bQ;hA4Ukr03N8CU&v?xI5_kw&G*y`5NL7Hm!qlRcHZqMh z7SA^HmC8l+M;+M!V$kB)bL13797|fva`0B^d9Jaro+%s58%*esA#D!BZw55*MH6?_ zb39wx!7S`w)=*yo{ZVps+M=hMx3w03Z)o&>sFhy7dsZ{xBi)Mj;|f(K@LeV}%YorjQ*pPsn+2rdA%YK>mfK>kHp60$v>GC=FyVxl mP*sKwf)BPY9%{gXJVX|u9)!WhJ4|@+{{$Q;2PZfR0)GI17L&#R literal 0 HcmV?d00001 diff --git a/test/bytecode_graal312/04_try_finally.graalpy312.pyc b/test/bytecode_graal312/04_try_finally.graalpy312.pyc new file mode 100644 index 0000000000000000000000000000000000000000..885d6ba266d52d970883d2e355e598098e14c028 GIT binary patch literal 1980 zcmb_c+iuf95MAGh+q6xw0)mPrMJf`lRLo6zK)?f{l@Jj~vt5N}sq9P#+LA7x$n^gPcvG#Oy70((MK#hxLm#-1sv=AI?0 zR>QkPv%+2`ijpXt1)`W2gHFA^Q2Eve2H+du8OBOfXjfCo{av@|tt)P=JkqhPMGlZWq>aVO5N=TYRe+ zh3UEoQ9UK>3HR(RTx;Tz-g*8|b`K_7YT^DXa#XUTl?ik>43V?|pcX1D%D<5M1B3n! zqQLdb>P)d_1bqTMG2tb^aWdO$I&CL%GSgeb4l`XSEZ3goX(Q6flb4a|KPAXy7z3e? zXTqc^z$6*QEGbKF&t`U^^A|+zo~{_PGW^dqo7a4jW$BTwgJQx+!GcteK6v zxn>%nr`E7Jr`9N{8QwdXqY{pnqvbXmotH0<^Cgilza{cAu2ppN`);O;~wPo38Doa+GTCcs{?kgB3w|Ctyuh)&2d2!fqGFOz3c7{CpH zhi?G)0NS2?#`;5NTAJrSG|>xd;nd7+A(}gEd|jZ|cFk_o?KNBV8f)0xRC1(;;a39; z0}P|6;k}2)vsrK*R8~ECdGYT%pO+W@-dN1%HpWXAWD$q&rv1SST=GGRG2tikChMi~ zu~cK?KxPei(Qr*i1IfMV&6y@aDBD4JM3?e3#Cu9?g&Lk~U?{M%1c@K52fPHRBhTKf zPh|2B0Ietg1VHJPJ$dT1p3$+VBn}{NKXo`a{u?oOMRd*4(FI~!`a)d=e+%GvarU1A aI{@vmOi7nQhkJFZ`5i;8_P~`zBmDqs(*Xkj literal 0 HcmV?d00001 diff --git a/test/bytecode_graal312/04_withas.graalpy312.pyc b/test/bytecode_graal312/04_withas.graalpy312.pyc new file mode 100644 index 0000000000000000000000000000000000000000..1a85a7646b3aa1ce856bcd980fd26a2508510021 GIT binary patch literal 2064 zcmah}U2o$=6rJ%$ntpgUu}rEKHCa#*Xr*2AfFd3cPg@CuKr09j@DjPnG_}?rmB-08 zkMVLVynhj=(|M%6+}4>wBNEE{z(@#BjHK}7$Pk_}GKFW3 zEa6#0_jArIjYFceMQQekatB|Bs5B3nN6k9e29vR|+yO4qEDrM5O1+u}OY%^sJU*Y# zj?v@h#$mDuqHsFS)GX9_7UW@?XfCcsGc{(bJs8F_m7o`2t(mw8BL(vh&yE*`hb8>=`J@A{i-M+RE@(ki+j`6`*D z(=eH>hpUEhzoW*9T!>>62LKmSs%k+?+abWj{v-8N4%|T4qgR3sX?t^Wo9x>?hHj(< zSYJK*P>pKE@Wz(#1O2xp94fTVs5FfMf-GeOsEIo6Cr z-5h`my$6u32gR(8VLgS3*1~lk0E{~TP5_=&vn?ii1lRy|UeWq2AHFINkJ3{k)E@yu z7nLp+a=;UHpTJUBIHF=#t_nvKPH`armcnMivx|RI;q*XU0~?`XQ_{?Se~q_DpR>ps zg}dWLWDd1#`>o8pHuOhQxOwUnwj8Sox$`>QF*NJAmIwPD&=>pPbO!PmdmqN%?g5X6 z?sE(jj{Rq8;5joqOBN1T@WlOp=1liQz{BL0t2c_49M}jA8)kS1$qb&yO@XimC{F;s za7+`@&{FsKWt@7rDG$ye8ysOAf@3v9_dS>Q*|(nrdgeSnhgM&{1n&zx1H*W3yC1^N zIw_6ro-Fp|KSdXpysDPBxY*s&+?Ri~oBW$xt6LfHrMpzYRArjsq9B382&&Y&Bz zMR1$MDM0xI;EiUYmGH^fVveB&tB(^Hx#5SULY+rJt~imw=$rvLPCJ^7@aQN_P+rad Nk>>Vt8r?A@L_vg=nf*u(Mu=GkoUg6I{ZGl`O01kP9j(^w zY?d9p)~#)tj&@FTx#E<1+{4j&Rh=AjTDBTjHG>?3ofp=(xIF5tUvqle(BCtQ$Fu5& zkv6rrw83|Vnc6xTIH_Hxv{}_Z(q?L#E81r@TU0Wmp6RwmC7eGE7Ulx*1_o0}-{r?6 zH^f#0>@pqriG<}M!1pH7WEn=%^=7OTKu9mQ5Q1c2m04$Ef5vaiyz|dx@x_d5g|)0; z#2+kB3DwaOb?jdqf7lKa8*DSTn7d5G;eNqDnLHN~lfsW0@UtiYKag+mH^TQd%sd4W GWq>ctC}sx$ literal 0 HcmV?d00001 diff --git a/test/bytecode_graal312/05_36lambda.graalpy312.pyc b/test/bytecode_graal312/05_36lambda.graalpy312.pyc new file mode 100644 index 0000000000000000000000000000000000000000..3ffa5618faa2d458bcc07ef92bd5c7989249f0fa GIT binary patch literal 2345 zcmbVOUvC>l5T8BoUF`g6QYXP7)J|NXl%TX1k>IB&k!W~8hzL2UWQhmMIbWPp&pzw! zoFpc6W-ecWkmmF&%Tt6L?%);zA)9<(n~b3~t|i5}(oK|9T$-tpbtVI3eeO|bF~ zbE#DMa*s-t?vXGTsHYinL3GThRC&6Wnm6|3dV!o65fuC>5@A>(j{Jd|)jAk6e69 zT&<>9=OaUStyp3d1U^=IvD=JTj*!KpD?CCs?u4yNl@J|kJg)ZS!q9EzJyH3hOo!sg z$P{RaO4)ffCacDuc~YOBCC$+$Z32v7o?@{o!zM1xpX}POrGT%WTp3AME&nQ}d%;R#fSC5mFN(AbgQ>RG@v4Md!_AXzrHy zeePKvXTfqTYq?LLg6qsmxe?g`W;Nk#IcCUhW_S!pA%W!u69$ljSyr$wNP8pU*Qmb; zbMVIy@-h#t-v%s({gAv{%%y(qMCLA6Ziy|)8}g@QovwW~5<~$~v_NN3R`$?P(z&tFB90fdDB;`k9Va?)uzz|uF3 z!@?Le1WUKTJvQG6>m^XVR7XK1Y^1tH6uDd8H&nMwrZXv%yXB8%4HGWl6Xs#e<2l2c zk!HcMXPF__ng3g}AcaVa_EwiDk9*WhIBaMRj3E1yO6c9RKN{pZ!KytWuW&O)t`mDf z>k0`9YfmoogS%!#(a~_%Y%v$)$9M6}(LPOmnESw3F;}dDRivVk69sc$WIkF%Q^dY+?6Y`&~v5_oGnx^Srk_}2W#v#s6g0P80A(yz8P^S9ODf@@S^jR%bH`rtM0+G&Ye#gc1xQhuwD-z&(C?THIR-PEscM_|G`TQpvyoDfB$C<=U&6)0V#%GVFGZ}Qx%r1@R~R%DW% z$XID%SkE(4qWdDJ^731FD{ehs-myBxcm5VzWJW1vRqdU;}HaF*fp z44)MqBORV)16~7cxyB6mW2Ez=-OC12x*~#@mwZuOOtf qPl$lX*bRgoF^xjQhUmx!bR1_G5f4>vAT=WVd-#6@PaPdnBl;KjadGwl literal 0 HcmV?d00001 diff --git a/test/bytecode_graal312/05_abc_test.graalpy312.pyc b/test/bytecode_graal312/05_abc_test.graalpy312.pyc new file mode 100644 index 0000000000000000000000000000000000000000..f4a9d608185203d04f08b08176622883aea26233 GIT binary patch literal 1711 zcmbVM%Wl(95FI~CLz_TJ4MZrLp2Wr z({prt{k`F<9V_UDZPjy)w?}IKDCoM*`r*FitAXhUs&DoBwyF7U=ozNk4m*z?st=xM zdfU)2U+o`BGel3X5WOzvIQ~Y@-4AVZbJPZj49tVpSVAhZR#Gh}0{g<6cwbT^s*AN& zyeG+uJS*3>gyIJFPNglP>uHN<;dhHgigWpO`3v{3An_C}F3DdjQ~|*W4k58HZ!ilT zD**jTwk^l+n?`_CS-#%(15Y=CMfR|OFPaYYOis+cW;ub`@$|rQ9bRz`GJ7XY44pIu z?#~AtaE8b;gV1x1%VR_zV+jt)fWuc<=IEBtx-hWQZwP?USs!s z%8=q`&l}rjpriI6>YMff$T!dxSh5{K*K#`SC&0>`<8rcamF)}4QQfdzL%03SY9rmB z_TaY6GE0h3Cq=whp}K(gCCXcZBBeIoTCMmPJ4P-EJ1P{Y5amlZ0L!Wqz zO0&ET?+Xu0(;U5LY8r~KY3aA1Y5Bx^7wUF83sMKJ3)R*=?i2hq8_2}qaw+hT>*Mm- zK~;9fPhXX(flCJ12sBYEqL|TgQh3}Nz-(63WZDA@Bz9CbE6Y!WEJYr$5PE={ zGzM3>=O2-7*t+jyE(4AM_)nKm16gDXk!QNw$pR&x%b?2&v#F|{%$5uj4xkbeJH6!7Y95rytZZ7 z=f2%;na;*%%QKFfexp-2+OBodHO{(z!){tRnx|)uEj+i=wrr!`Io{ed zHlK>R!^_2y={R-MI;oy@vvWk>CW+pcbDU-S)IIDt_D!X&g=z zE>$duq#{BUh~>eQA4G~Y9RBIKT@MGo6A$-PbN^q`^yxIp8uX2g|kyLH2Yg& z7W6D{hZ2}Xa_b*$%g2Gh(zEV!x8bMme=v>;&;vrW%u`zk97u?$ zIfN(-MxQ#S6U|0rE3Q=to*n_}?BAh^UitctPk4thDX0oDJP9&OfDep44J-%6iC+bj z3c!t$J=;0Lr0X~AHtPh4-AhJnfDjNg%~E2C5)GeM42+;zC75ChnPeO;=mx+oL!tYl z9nmZQ(@X0d@qdQWotI9D+BBBYKGD^hwu)t`u7@2?=R$tRSiVvYUo?hNNkL#{S*P>kU3;LPQC+c!Tk&;r@xjz>5TIQ0~9wi>Mtn=*?73TVO|^ zO`!2|U&&pi?UkPtwWY^#AIe!!n}6Usvefs&h8VGUW66Juzc2S5xm$uZ84cR|*Ls=)}x$RR(j bt862VRRVdQN9@5};2jwSJTeLzy8?d!K4EHC literal 0 HcmV?d00001 diff --git a/test/bytecode_graal312/05_empty_ifs.graalpy312.pyc b/test/bytecode_graal312/05_empty_ifs.graalpy312.pyc new file mode 100644 index 0000000000000000000000000000000000000000..6a03c1f7358bd676f342821d7bc2af52c793fa0d GIT binary patch literal 367 zcmaJ+!AiqG5S=y~o0JG*dhjCNg?0t0C-DnBL~1WyhBn={i%B-@ZlpQJU-P3p6ww(f z;zb|K%$t3~&YR2G@el~qeJGs$*+bpFu`Ex7l)^ANU z-mSEgUO6wFF6%;}GmXuaTsE8Qsl1w^Dr?`OUb{)%1}6aT^!5BaqI_GLRa2Ve*1<}W=NV)-)An76jqKk+7?m$8C!hptj1>#zh pKRobiQ4;5?5y`l*9+8?qaYRb^t;SRn3O4s2SpOvO3|Bsg@dci*Mf3mw literal 0 HcmV?d00001 diff --git a/test/bytecode_graal312/05_if_and_comp.graalpy312.pyc b/test/bytecode_graal312/05_if_and_comp.graalpy312.pyc new file mode 100644 index 0000000000000000000000000000000000000000..816763b5f5621050dd197b9fcaa66aba203adaa5 GIT binary patch literal 1500 zcmaJ>%}*0S6rbrX(o(9@78ImKdNjhKhK&aTH!cb>0tqKK+uZ>g_M_R^3iZUUf13US z9=Lk+#1#{x0pD-S)U6VK@b=An^FHT2c(PNOV1#7;^U)b+?9(0zhKw9ToW>#wY;Wnk zBaOpOeAH_jQRp1^jcz|a3WKFnwM$k>n_zv~H0hP}uUM!R?T!ZcP^tM)6l;pCh_4f^6TUR@;Wj`1{p^sV%E!55jdeM#vxdNII%1` zjR5ACcjyy|xEBTIjSH^70IW17J14;|?W9gOB{2(o| z0dU6?9fY16^gK!L$4i9i8zc?;Twe1+$M)np9h8Cc zCOd}osB-^tlf9Z-;EQaVT5s|<#R5&_wZ6gMwYDBspTTydkGh^-)rxGYqF*Gl6egKX zX0-HLwFcuFoCv5Aw7i0epebTm5BY|ngViO<`;dM6&;jtngOrIdxfT(s2Gj#GHZ@TE z`63*3Ss}7~;kQL(1-36Fq9TbeV%zZ~?12{ z(l!;}ecY;4XJC}|GR-fzR+`}7Cx2z~zng-X$FRS(T3qCTk>ClyO(IkPsNEQhXwco@ yHop*91f+qt8X;uRZ3}@d1XMPR@NcLw;|?()gXis(jf#W+g8v6BR1|Pj2>b>pqwORB literal 0 HcmV?d00001 diff --git a/test/bytecode_graal312/05_nonlocal.graalpy312.pyc b/test/bytecode_graal312/05_nonlocal.graalpy312.pyc new file mode 100644 index 0000000000000000000000000000000000000000..7b204ffa088bfddd658fec36da338fb5c05f7600 GIT binary patch literal 789 zcmZ`%%}&BV5Z;z5gr5LKq7sqlO%qrXq9+0;uN(jqZw-_UZ75x`+ZwoOAH zerv|ZzQfva9k%}ffg}g)kP^8M28wo|+~^f_2g!0#dxsUZIPn5Z(|{w+og_$?dj=E( z+7>YEYabTDJYTr0YAiOU#&a;`2qI#sS4Ag9moRV9jUx4pPS3Wa=ss(CI z*WO?y{}^bQ6iKg(2?$nzQK_ioBm|q-5@wEe251gViy0oDG8e26nA#PnuEIe^DaWw0 z>9)}dXD-`~$cf<*uo3L>3|dKMb$t3j&1dq;M`3+filR1hMDFboHyMXtG0eDDgfQ_;U+;wmkeDF2G?*w8S_{XBe_@Tep(}t-4 literal 0 HcmV?d00001 diff --git a/test/bytecode_graal312/05_return_in_else.graalpy312.pyc b/test/bytecode_graal312/05_return_in_else.graalpy312.pyc new file mode 100644 index 0000000000000000000000000000000000000000..d659598e6c18f581a610fd443d368fa65a991b01 GIT binary patch literal 1134 zcmZuw-%ry}6h61T>k4CRbR-~iMU9zCf;BN1O^hT)pPXcgnDDlgtz(U)Tl#~*WBae^ zzrbJMgU=FqSdifPN=t^}YtB9Ao_o$c-@WH{<4bj(7|Hz~qoG3deUB$r81yaYIC28t z_BN0Dp>^O!qj=v6#{F+6*5o7_js4Bzfg4(p6Gm3(9!@-`7mnkg?^yfs!OJb{#a1tH zqB!t-uHSRK(0M*NQR_s%RidvgovXY(91mj8c{gi=N&#j=2Fo@zXfNFra#`#uw5+@` z9wQ{x7h3919$`V!Dy8M6SwTH6mx=2~b8JrRAap#}cO*}Su0LRP3y440c(`VN+Pal> zYXX7=koKCz6dH9oDlQqF4O4X63aybz+v20rotLz&tc#9eiX&C;>KesrN5;~KHRC&lhtN1Xs~aF?=Nvs4jCqb| zYAW}m$xBpU6lZnfFI86Lv_jdJRJ3UomkWx}w&&ql*^`Om58%XXFg~Gv)GD~g<6byWSD{|xQ1e??>=!_%%SFZk x6k)_oHVpIAG~>P)Na5KnfU5w*#0`O@wG^69G4*;z|`cAtaDEAO(a3h-1_^+s49;qqQB98=DIs z2EV|O51~{t@6i~w@K(<=JG=8{cKq<|jV%G}-nZ#zCGzzHHeqI>P%m?BX2;3FBFe(k zIG+~d(4^7FRXAVe({y&QoWxm}>nsnm_-vl&QI-}a(&4x`JsO0Ek4L##jXq7|MCYc^ zkLD|zVBC8D$A=C95_edLi(z1-t3C>q^G=otyepl!ds}O>Z?~f!|m~| z9Je4C4T5OsOa{RaY1UI0%DU@@Z+-WC?F6>t*43{jf`K}33YKjvL>i(lmu+qRw7yv1 zdJVa@9zc(+@z=bZP4x1GF{xpLY&_G+2~T5w7T{kn@R~agwGQ6j5Jo6^xFIi6stFP| zK_BG%Sw^<`;aFRj4x*0S-T40*rj%vLY|feLL<6MHPN+_wzm(PJGlnt$$+-i28{7kV l#yBL)jdb}VrpJMF!5(-O)jMt>xC64vzhI1tjMK6T@f%e?YZCwf literal 0 HcmV?d00001 diff --git a/test/bytecode_graal312/05_while_and_if.graalpy312.pyc b/test/bytecode_graal312/05_while_and_if.graalpy312.pyc new file mode 100644 index 0000000000000000000000000000000000000000..dc7803989d0a563c7fb20ccf1f3ef4ef83bb2e69 GIT binary patch literal 825 zcmZuuO>fgc5S@)3CruhcoA4n-Q=|w9A(^cN6|Mk^v831 zIfP1pHk&=;jwwODkD2T&}BTr)YX-^(JAAOv8oE`hq zk$3uJu`+HFeJT;X-K%nq!?R!-&z+;|8jTcSBQ-dVsYUP8H^OX--tIl@rd!Rn@twa= z*8>G`%;4~RWih#q3KojRAAl*tcIc=$^uO+1S+5j7#s)a>lA}X|+xRZ2I%t&E;#gD~ z!$+oGlq%ap%cB0B+%&9JX<6PEeQRm$i&sY-vD@cslA1}~Ewe0sR(^DE5{ELBJQ4b6s_K|1W;P0U^{69dlI0(+i=5T3nDVlb(;@vvB%>klxBB)!H$`w|i;RS>C28=)XrF3H&hliP5&vB_hK z|CxV7AAJ^IBp`jL6zhDKT#{D&@m*$jc6WB>+nL=w-k-TijKOOD%|H-++T(%cdsWNn zD#vr}X6{4Pw~iXB-lvWv`7h1B`X*$Je9V9|TSV^;#i3}7__1dhpTE zwqp+reKVDTbwAI)lL+;<_;;d5N8iA>5GQ(U`G-y!${;vg-e5U=C%u-faOReDRo%1Q zBZtpTU7Z`->v4Mp*mRnn+B&6TUkGeZvM^nf=4po#&r-K}+)rfgMR+Cog_)e^V1{j+ z3u-8*30;qfi`YftGMK%?%Ww(K4OgK9tF?7Z z+Gr{)e*_YhU_qZ}0h_-7?isMUWQ2)A7~B&?hK___ox3q&BQ1=CI!pumg5qE!2Iz;m zom_&eR|4TeK!?jc+81RJHz%dd5`VM$fZOwp(E$Rc(D^cfSWPN^N{Bic@gO)1X5sy} zLYq7}q4qzuUf~@wSOQ_LhNEjOHV#eU z967=RLCvs&F$8Ov<8BNv1`rbAu3vbD*a@>&s literal 0 HcmV?d00001 diff --git a/test/bytecode_graal312/06_try_return.graalpy312.pyc b/test/bytecode_graal312/06_try_return.graalpy312.pyc new file mode 100644 index 0000000000000000000000000000000000000000..deb3998f7917a1afb1ac8ec673786b92eed9b875 GIT binary patch literal 764 zcmaJW z@K?BYAt-u}G_`c$3FqDK`))38=g;yIF@E;m|NSzE9{#c+v{(uUb`FSsnP zSg+-`aoNpl#*0nP*mTCWo3C27_3E&rMzx%sZeF#?t2oadd3m)&(=V^vPd2$!r@F=M z3iji4flaAYqLx`H{?_lrS%f5vt>xebdRuj2BE(_}{N>eiiO*}@?#d$su>TsfJ|PR* zWbRCe?V%2Bfhx1X#D=zLh0m|pr}6zUX@hEXMRx$x7B}HFLdRt943r=jL~M--KZ_~m Pr^Cyc0nDNVvbgpGK$~=* literal 0 HcmV?d00001 diff --git a/test/bytecode_graal312/06_while_return.graalpy312.pyc b/test/bytecode_graal312/06_while_return.graalpy312.pyc new file mode 100644 index 0000000000000000000000000000000000000000..b64c1ef01c8974bfe2e1f83d2c96bd4176130ac3 GIT binary patch literal 1437 zcmbVMOK;Oa5T5lqvFU@RPKuzAfRF%D5!~_!2M|2~w^CK2MHQDScC5xCu`549d&4;( z{udm%_5wG!!Id5gMPWY2iAp0u%V&MFJF`2pvoo8_J)0aO#_J33n?*_V?l~)F7}%z> z9XWwlZ&f>XXl}YuGq%jYw_om_FZ$n zw(+XzvNdp`IPh+6?Z^Vr#}^ zNg0}RMXG6M*Waw>)sn0kEAa20D$K}lEX(o>%PaB|%RA}^mRJM36V%lTXXICw75SOv zRhd_RjD6%8Rt^)1s~ncgL#`KLYWaR^GF9Ektw(%!$7`HEYPiLQKcKO;Cs@=|X{FNM z!(F|&jUdr(c_i+L0T~Q{r0z2-w47%tRu&Y>bwovUgr;aZEg9A<)hF1+j)h?_$wo!4 z=y~cW7nO=)JiS*lmf1ZS6Qt$E_pV+@^sX!=6Cx*6agh5tPU)9SP46cqN_a)r#J*1H z*Hy;#U&(Y*5Cz|uKS1_r4InHC`)~nR9|DWWjt?V3 z8D=x`KN4cBFZOiM?}7JOa$;nLP$#!WTBI!M2B>{U6G1dGr~LS`c6Wq+{F d9>Ei17APGC&+QUxApWra18^IJ#)#4YzX9V@)g%A_ literal 0 HcmV?d00001 diff --git a/test/bytecode_graal312/07_build_map_unpack.graalpy312.pyc b/test/bytecode_graal312/07_build_map_unpack.graalpy312.pyc new file mode 100644 index 0000000000000000000000000000000000000000..98775cbbdf151074e4caf5c8e548f31e4f9ddef4 GIT binary patch literal 701 zcmb_ZUrQT75TE2Omqe?zxg*vGg9TF|C0#*O5HVOH(uYb>Dp4%wa)`dznUfTK_c!e9&TnRaJGBY|1?00!tVooj=U*Yj1S zmFrx!^2bW&VjHqp?Of?lRY%Np;ZvdB&Ka7nRg0Z>=u3xlM@D(2azOI0A8lAJ!3@mY zYD3UKH^y!n@0I)V?*^bfQsXyk3ni%Bzx}laXv3lg^OZM$=I_*DQH2SpO{p;Xw+6L4 z73xr@3(|wql`PSVEFt+Mt~W(5@p%w`B|>P(WGV5A>KwU19m{npEaR38weOfxl3_y;ynijn{T literal 0 HcmV?d00001 diff --git a/test/bytecode_graal312/07_forelselast.graalpy312.pyc b/test/bytecode_graal312/07_forelselast.graalpy312.pyc new file mode 100644 index 0000000000000000000000000000000000000000..f29e435f853c0aa04961e464bec33729e767693c GIT binary patch literal 1003 zcmb7DO>fgc5S=)2Vv$s7(g>o~NhA;=id0OC1P2fxp`MxmQt5?DZ{0LEg26|OZlQX7)HBVl@!=t_iq&JgS2k(b9yTYtc|;=(_PIt=PI# z{hgL=Vw6nXN{fBnHYpo=uX3gPr2G1Td1=x1%}9-wMLcw!tu|>}-&B+DR2X_{P zOT=VOtk;5b-d$pzN}1`2t6*(2kmoMrfPwb`-&+9(gWHVU4n9}`DZydO?T5_Ytblmb zh8sbUdxwE{WI=fL;XvQ4GWP!y+D3GZ3Axb)+yw{V#{$PaaW;5^am|u<8+G!>L@yY5 cEHr9|KjPreYAyfX>86CW8OuBb8fhSZ0csVM*Z=?k literal 0 HcmV?d00001 diff --git a/test/bytecode_graal312/07_kwargs.graalpy312.pyc b/test/bytecode_graal312/07_kwargs.graalpy312.pyc new file mode 100644 index 0000000000000000000000000000000000000000..5e9dcc06e4fea160b1e307439ab312b6e9edd793 GIT binary patch literal 612 zcma)3O-sW-5ZyFQYPF)YdJ%Kz#e-5;D8!4Hqc;&$$gLk~nufMX*(A0-TKpsWPelJh z?_LGLi@6j<=e14Hn=j0~+1Z(w8Fv42eU%Yzcb_{i#7`IGcpxlpk3w5`jb7!(3b^Bj zov6u$Z*|9fFb+GuR~fb3fQNPv^1$s6dUh@FBVpOR897y*A05}a!-jBz!@*eIWb9pH z>{?qP^^?BeihB0x@0ijl6pHr93|5!Sdm~d~hOC=+S6OvSDoK%KJ{n40GSqs`d^juW zRJo(hl(&hjF|vaELH-~+U7nGfs4OE(U*$r6wy~{z=3mQ?+!9Y(^NY72#hr)?Pw03)jxp@xBAYlsO@TB@b;sO}DNn*bW; z$pMTO00U@bXi2j;d=pRvj&l@X1J`rrqc7DnYyiAf?AlC5+p<=BsASjg#-hN1cNGAm`viPhBUEkr_%~H z_7)+85E4sRA%sRO*&^{9*swrsW`x87O*^BuYNK*KCyvs`VvhCQ^WAgL>pJ&3%kSkh zM)KX^uOB`T8T*PJ4B);Rcn^ z3BpR??szT74mw@G?o{q|o3E}_UU}W740g?L+MjfHyqCRwVT`ex3S)QYGgRY^olc|M za&C=sG?EHOgq+#?j7_n%35sPbE^DJeLb&A!_EyK=sfBhos5KqPNt?XOIsI8vZ>wXEN*S$EqXzbBK2ZxB^r}5A}eYl(@qPgMOHkX zKbF`cTa0;CQpKa(X*{DQbU}VR&FG2wi?fof zs9F6LFN#dhi)`wke5ggbAj)TYUJ#`-?cm0&_HeNmkFCUfA+?KV>OpB% zRJ4=vhcETw>{2u%C>ItD?$PYY^G9+tsrF*298F1VIj3r>F8@1sxXkE@it1@Bl%qLS z7tdu?J(`%3GxDFSw8__Eex7W^^06?Pw2|Wu^S$WSl|0c5f~BMUu@v)DA}ftc|CPW+ znaKhjxjcccA#1qx5J%AV{7w_bju*O}wjG4N+inIjS!$l=v>Rakv#$=lYOO%0iPs5S z1kn^;_INy7;VmBwrGu zGyR&vI#cPnZUwEQ_T@a!TK|IIwL9*6T+WYQIF0lu*ROn~oCgdYjN5U}=u z@MORbNEgTmdya;45^N1~#9|*aG{F&r4gKTbfunz%Y4DE-_`d?jUT_=0Q4{A0Kha-= aM+DSE9il@?k5793kat8dO+%oO8uC9wl_|~u literal 0 HcmV?d00001 diff --git a/test/bytecode_graal312/09_while_if_while.graalpy312.pyc b/test/bytecode_graal312/09_while_if_while.graalpy312.pyc new file mode 100644 index 0000000000000000000000000000000000000000..8147826cb48c38f3bc64d41b8fddffe3f7c30361 GIT binary patch literal 800 zcmZ{h-AWrl6vxkGW4<)Oh8POswzLTzS&i9cKh#`qo}%}C zh(17{!8h;$1aG7tZ2$k74U6Deelusz|IC@0v)iBRHGzG*|MBG(^Uo6uIt*;>Tt`kY zvBsTCJJhFcG>Qj0@a*%c_NURvn{=*+Zm1(CjCAN;_+zIZdU0SodJvz!@9K9S`d1?t zQTOYkv+GZdRgv!nk>iaDPWgD@4db!%Deoh^Fa@s+jzn70ZDOy;tW?j#f=pWjecuW~ zr$6-UXzJrK@gQ^}?#UaIZ#JGye^w~wir@j#1*Xy4!zjJ2f|%-3mDMX{D$^)84y#2m z3#O{{8l{DFuzs)?r_FurOls=atk_PL)!&)XPFB>C`dt#0G*wakS&~+*Tu~3TyQH10 z&LzB3A@8AT%rC+V@i8`sGqx$Pu7*}*aXkSGW8g4bvDaCND*QU&TV8-{G?1~5)iS=! z3jYs-@F>m0yhNHx$_nfXkD~Du`X#{MMy&x>Kod}7{3W2)1}*RgPF`mM*W-y2KsWXmgVNYMpmgS7gYzt?Wr~L!!347E4 literal 0 HcmV?d00001 diff --git a/test/bytecode_graal312/10_complex.graalpy312.pyc b/test/bytecode_graal312/10_complex.graalpy312.pyc new file mode 100644 index 0000000000000000000000000000000000000000..b1497b60759968aec3cbdad56754fe743eb17bae GIT binary patch literal 3472 zcmbtWT~8ZF6uq-+drfTCuy#m*VmlBeY17~&sI*iF6&jFQM3g2}N?&3b^%^#PQN@-q0Qz?B}msDsuB&qOnSW=PM$gFX5?lUcAq@v02 zyht)KFV-5T9N7Q4`bhW>H+o8ZxW|UVf4cfv@!^KWjSmv8DQ zGJ4xIY<~_6Nm}L=N;R*HzH8WHTBU`K&PYb3)m<^-*Akj%xj1 zbhpXvuvgl$QMQEq)u4xP_k6@Yf>TZb+;qG2w|Bg@j*lH+4<(z+!XQpcfAi}+;8B2w zmj%+mX@ENN9|F{U089W=0CnVFLAWUjxgo!1`yGJ#-I1>F>gopLVeZ9h7Bx?K0H+CP z^Ln$Zp{se_N$V_ZTrFfKltiM0{`;7WIo*VSDvNp$phIK$ z4Wr&qoPYs&q`aARGr&0+zsQwvgTe7K`?*x|OiJ>63VDCFC+mQ(<1QF^CjpKl|1rRE z9|4oVG(a8sD*$zKz$d^0KplC8V6Yx?Tni6?9Opj|(Ecl+8Lr*$LU$jAE#bY-Yhzg< zl^f3+k$Ek)Fe=yOhFaF}_{A172$&XyuWT|&)VA5K|V8_ZP!vFWQ2(Bisk zh0V26N4ilSITysV`sAHwZEX_)0Jwm zP_bvw2y8fKAoO_>xS37MqM7j@yIZ46amx!_Y+kaadK`|ZXVF()kLH|$8@gSo7V11_ zV*DcMGH|4fLBlX&eHq|f6z-)>I9pTM9;b{2YWNj`x@LU5oewwCT@0{kLg7VCc zI9RF!IgQ3~fHkibu9M`Ttf!HqvEyCpbplDrpL9v^c)kcm1AhTJHnXq!oK5=;^8bzTf&)`ezR&; z3;x$lS{&!ANIwEoh&RV55MEMAAUXaAU57V<54Jr`FXeVGMEb#Z(VaH Mu8R z9PGb?zXQP)Zk!O(3UOFYy{*IwR-u%oDl@55(yo>Z6OCrx%)FVO-RSwGPqr<+cErJr|)@#mj**_4&b#6z$Pv`x1z3RQJTnhvcAI(s+dYO^;F_i9C{(`u#WQ??7dVg}&z>YJGTdM)&0{nr z4Tb@!eLDzABETb(j$ykft`Uo?`@3YiSD(a8B>5(UhX)tPD$~vaG?!Vu&|;R^7OOy+ zIfAU;{)GiWMff`+4=USML{Oo^sq7ZB%&D9RZBYXK8@=4(Fp95IEMFEYnJoaJ#b4Q^ zqYJ5$Z3$Zp?!SuAzt~q~BZrr1>XE5?O3wHw56}{?_Ob1^WP#y`zRD~i z$jHllOR5ye8!^pQRzg&S;If)3sC)*nqAr+v+0^HhIU|SXY3f;1=eoi>_alK)HcM|Z z012Cs&J$jV7x_mr6cd(YT;_kryU8-AxrCMZzY--MOG&jD7dX7xXKM0EA}+)$94H0( zH|0Sou9W^RpKD732nqXQ{si|zEuJG$f))D3b9}RaCwK1A$09;I|Z*aV=g1 zk(#uKJk_iNBRs?-hk@_)e8cHr57T5F(fs<6+X+nH9*o=B^n8mVtz*lKLfb=MXoOLK zeM!4bD+oM4O+|~2={b(!cE>YeyWs&8jeN2PdwWtV7tR0w4Ci@JEZxbyxsjC1y7@=u^S9&dkHuaDy`ACkH65h(2m(M3cC&J{B*pkErsFr==$~UhbvotnTPp^zI#66SsC?yLNDB zb+t9^Ze)j==W9MbYglkZS8(T2N88;9RZLL-*J`^xZ6(k?!}n1`WRYXJVX!&EApi{- zI|g3_&aWSBBczh6`4|D`TH zb@#Yh4suToxbC2a!E?AkLWMTdVG&i3Nnb>+rFs?RYO2!(znbbzl$)tewr;BLqx?G6 zze4$As{erUXJo4P6Y@P|fkwM&|O{p6zQ Q@9n>dA|_c#Qf8um08U3n$p8QV literal 0 HcmV?d00001 diff --git a/test/bytecode_graal312/10_long_pop_jump.graalpy312.pyc b/test/bytecode_graal312/10_long_pop_jump.graalpy312.pyc new file mode 100644 index 0000000000000000000000000000000000000000..88e9afa5241f292749b673d8cc5dc4708e6b79a7 GIT binary patch literal 2747 zcmZuy-EZ4e6u;MYVkb`1G)+I&bxv5jb?UmMY*MucG_O;K1S+T!AP_@}yu@p>CQf8K zUHj;0;$cG51WyPF2_c@~3Go-eD?+?X2qa)a;!B8urUkWYyYf3XZkl$z$?u+X&;6Z` zdmW!lzS0wC827)tbNyVDv9DgoBJa7yyuIq%u47fstQ5WcV%cA6T+6$);__O)zUD90 zoHMJXvX}R5&(C}1YQ16?yjsI8+WBjZ#q%@yXQvC5nzLA_*Xo5EjcWaDeN9d=W+K~b z$225)u39TKD)z;0ohsQK9Eu9O%2Bs6p(0rK;3dZyHK)=70b2!a?K%r z_aNfEV~0`?HA-F15$GQxzz8!WLpmjCm-!XdSU`D=o%9GFVOMxoZf~wgDg(ik)Wkxs z#0)kh8GMeX=O<}jGi9IiB;FMpKn2mn#pYO6n!gL82I63bqU{x|Vb3=r3&}w^BO=GT1TLL(ewc+d z3?eieinnvpQNfzRUd)V}x|w*RgvkA)#L>+jLs8?qwd!V)RJtVH>=joiHg_+{pi7$M zFAbsApYenORn@q}pUCTpRP5g)+d*HD;_I{I?3WcV~CtcKFcgCRB)^ozI~iB6#OY>>(fs4@Oa4&nPnQAdJdI(~}dT~fC= z(}Nz7cC*&89vZBzS~xM)7j-4nH>AsVZ_Q$S7?5s3<_?KaC^s zsi05miRtk~REyo8d^CfbyF|5{`l-{}z4I-T;Unsw*2i1Z44d5hc31F_)Yszg9;NCzeUL_WoMa^wG%; zLA6)wxb*|fZrU^ZX(!xHye<|vV&pL6KT3>qnCY2QTkamz%byxDqvMNl$iC?GhuC*r z+LB`IBXuuyrgv>hSnW%;m;b=V{uH#@qjm*s(~dr63EjIZ2~9$@?G*87$Gpeg)4FnY zcx`2mb714ZQd}Wy6zQN3{oEPb*%5*sR}vaMHF~j50OULd&~M=^KzmcbY^a-%&xiUP zWEmizMS$LgWq^Fhz8dN)kZ%LTy9G3X+W_&%{%)w>g?um6$@W30zYqBdK>i;C9|4~M zSU8ZAP!9P^Ty0L6X>@-}c6z*pFJFk;YYKLQkibsz%* z)$k%f?-23n$3*RcbPFIp>2#0udXi3eMZJaeUjgbZq^B`aE~uSBJ~Vb;Y4YnDwA^(e INnvRG4|h1P`Tzg` literal 0 HcmV?d00001 diff --git a/test/bytecode_graal312/10_while1_popblock.graalpy312.pyc b/test/bytecode_graal312/10_while1_popblock.graalpy312.pyc new file mode 100644 index 0000000000000000000000000000000000000000..392d16013f63cb79bc059f72fbb2e53d67f27644 GIT binary patch literal 1029 zcmZuw%Wl(95S<%4wiCNeW2F?RY8DV7fr5!DxwP;IgdN=*ci&BPcM=T7quNo=_VvK>1KqcWu4A?Rap-j|y%Y8~H}(4c z_WObDSoO9$b~_Fh-g7713cxW3@M1&4HV=p6Ug%icSx&Ref#ZOP@f@H6TPoH9OmW;y z(1v6yVR)9=8=AJ$HQhJZnA};A?eoSZ#!Dpf&cP!IDOl?OKm!3B2H#+? zTQGQ97n%oK>M=HsitJ=6uSX^RuXLs^+BaN?Zvo z=LL2m{f?>-Re2U&iOcY)O1~0zEs{Br|0ADGx%Eil^W13xR?FPCRlwggca{5@Xr+i3 zK)}Za6nP9k@NAceXO8-ofW&lNYt+jjqw{j?kws_t7GnYOKb?_$b4FrJ_4sPinxJ6N z281#Oy_