diff --git a/changelog.d/20260105_151912_iglosiggio_struct_methods.md b/changelog.d/20260105_151912_iglosiggio_struct_methods.md new file mode 100644 index 0000000000..293b5aba61 --- /dev/null +++ b/changelog.d/20260105_151912_iglosiggio_struct_methods.md @@ -0,0 +1,43 @@ + + + +### Added + +- Instance method definitios on structure types (`typing.NamedTuple`, `puyapy.Struct` and + `puyapy.arc4.Struct`) are now supported. As with contracts @subroutine will be the compiler hint + for inhibiting or forcing inlining of these methods. + + + + + diff --git a/scripts/update_typeshed.py b/scripts/update_typeshed.py index c544e6b393..d010b7c3a7 100755 --- a/scripts/update_typeshed.py +++ b/scripts/update_typeshed.py @@ -70,7 +70,10 @@ def update_puya_typeshed(mypy_typeshed: Path, puya_typeshed: Path) -> None: stdlib / "sys" / "__init__.pyi", stdlib / "abc.pyi", # needed for puyapy - # stdlib / "enum.pyi" + # stdlib / "enum.pyi", + stdlib / "importlib" / "machinery.pyi", + stdlib / "importlib" / "_bootstrap.pyi", + stdlib / "_frozen_importlib.pyi", ] (puya_typeshed / stdlib).mkdir(exist_ok=True, parents=True) diff --git a/src/puyapy/_typeshed/stdlib/_frozen_importlib.pyi b/src/puyapy/_typeshed/stdlib/_frozen_importlib.pyi new file mode 100644 index 0000000000..58db64a016 --- /dev/null +++ b/src/puyapy/_typeshed/stdlib/_frozen_importlib.pyi @@ -0,0 +1,124 @@ +import importlib.abc +import importlib.machinery +import sys +import types +from _typeshed.importlib import LoaderProtocol +from collections.abc import Mapping, Sequence +from types import ModuleType +from typing import Any, ClassVar +from typing_extensions import deprecated + +# Signature of `builtins.__import__` should be kept identical to `importlib.__import__` +def __import__( + name: str, + globals: Mapping[str, object] | None = None, + locals: Mapping[str, object] | None = None, + fromlist: Sequence[str] | None = (), + level: int = 0, +) -> ModuleType: ... +def spec_from_loader( + name: str, loader: LoaderProtocol | None, *, origin: str | None = None, is_package: bool | None = None +) -> importlib.machinery.ModuleSpec | None: ... +def module_from_spec(spec: importlib.machinery.ModuleSpec) -> types.ModuleType: ... +def _init_module_attrs( + spec: importlib.machinery.ModuleSpec, module: types.ModuleType, *, override: bool = False +) -> types.ModuleType: ... + +class ModuleSpec: + def __init__( + self, + name: str, + loader: importlib.abc.Loader | None, + *, + origin: str | None = None, + loader_state: Any = None, + is_package: bool | None = None, + ) -> None: ... + name: str + loader: importlib.abc.Loader | None + origin: str | None + submodule_search_locations: list[str] | None + loader_state: Any + cached: str | None + @property + def parent(self) -> str | None: ... + has_location: bool + def __eq__(self, other: object) -> bool: ... + __hash__: ClassVar[None] # type: ignore[assignment] + +class BuiltinImporter(importlib.abc.MetaPathFinder, importlib.abc.InspectLoader): + # MetaPathFinder + if sys.version_info < (3, 12): + @classmethod + @deprecated("Deprecated since Python 3.4; removed in Python 3.12. Use `find_spec()` instead.") + def find_module(cls, fullname: str, path: Sequence[str] | None = None) -> importlib.abc.Loader | None: ... + + @classmethod + def find_spec( + cls, fullname: str, path: Sequence[str] | None = None, target: types.ModuleType | None = None + ) -> ModuleSpec | None: ... + # InspectLoader + @classmethod + def is_package(cls, fullname: str) -> bool: ... + @classmethod + def load_module(cls, fullname: str) -> types.ModuleType: ... + @classmethod + def get_code(cls, fullname: str) -> None: ... + @classmethod + def get_source(cls, fullname: str) -> None: ... + # Loader + if sys.version_info < (3, 12): + @staticmethod + @deprecated( + "Deprecated since Python 3.4; removed in Python 3.12. " + "The module spec is now used by the import machinery to generate a module repr." + ) + def module_repr(module: types.ModuleType) -> str: ... + if sys.version_info >= (3, 10): + @staticmethod + def create_module(spec: ModuleSpec) -> types.ModuleType | None: ... + @staticmethod + def exec_module(module: types.ModuleType) -> None: ... + else: + @classmethod + def create_module(cls, spec: ModuleSpec) -> types.ModuleType | None: ... + @classmethod + def exec_module(cls, module: types.ModuleType) -> None: ... + +class FrozenImporter(importlib.abc.MetaPathFinder, importlib.abc.InspectLoader): + # MetaPathFinder + if sys.version_info < (3, 12): + @classmethod + @deprecated("Deprecated since Python 3.4; removed in Python 3.12. Use `find_spec()` instead.") + def find_module(cls, fullname: str, path: Sequence[str] | None = None) -> importlib.abc.Loader | None: ... + + @classmethod + def find_spec( + cls, fullname: str, path: Sequence[str] | None = None, target: types.ModuleType | None = None + ) -> ModuleSpec | None: ... + # InspectLoader + @classmethod + def is_package(cls, fullname: str) -> bool: ... + @classmethod + def load_module(cls, fullname: str) -> types.ModuleType: ... + @classmethod + def get_code(cls, fullname: str) -> None: ... + @classmethod + def get_source(cls, fullname: str) -> None: ... + # Loader + if sys.version_info < (3, 12): + @staticmethod + @deprecated( + "Deprecated since Python 3.4; removed in Python 3.12. " + "The module spec is now used by the import machinery to generate a module repr." + ) + def module_repr(m: types.ModuleType) -> str: ... + if sys.version_info >= (3, 10): + @staticmethod + def create_module(spec: ModuleSpec) -> types.ModuleType | None: ... + else: + @classmethod + def create_module(cls, spec: ModuleSpec) -> types.ModuleType | None: ... + + @staticmethod + def exec_module(module: types.ModuleType) -> None: ... diff --git a/src/puyapy/_typeshed/stdlib/importlib/_bootstrap.pyi b/src/puyapy/_typeshed/stdlib/importlib/_bootstrap.pyi new file mode 100644 index 0000000000..02427ff420 --- /dev/null +++ b/src/puyapy/_typeshed/stdlib/importlib/_bootstrap.pyi @@ -0,0 +1,2 @@ +from _frozen_importlib import * +from _frozen_importlib import __import__ as __import__, _init_module_attrs as _init_module_attrs diff --git a/src/puyapy/_typeshed/stdlib/importlib/machinery.pyi b/src/puyapy/_typeshed/stdlib/importlib/machinery.pyi new file mode 100644 index 0000000000..767046b70a --- /dev/null +++ b/src/puyapy/_typeshed/stdlib/importlib/machinery.pyi @@ -0,0 +1,43 @@ +import sys +from importlib._bootstrap import BuiltinImporter as BuiltinImporter, FrozenImporter as FrozenImporter, ModuleSpec as ModuleSpec +from importlib._bootstrap_external import ( + BYTECODE_SUFFIXES as BYTECODE_SUFFIXES, + DEBUG_BYTECODE_SUFFIXES as DEBUG_BYTECODE_SUFFIXES, + EXTENSION_SUFFIXES as EXTENSION_SUFFIXES, + OPTIMIZED_BYTECODE_SUFFIXES as OPTIMIZED_BYTECODE_SUFFIXES, + SOURCE_SUFFIXES as SOURCE_SUFFIXES, + ExtensionFileLoader as ExtensionFileLoader, + FileFinder as FileFinder, + PathFinder as PathFinder, + SourceFileLoader as SourceFileLoader, + SourcelessFileLoader as SourcelessFileLoader, + WindowsRegistryFinder as WindowsRegistryFinder, +) + +if sys.version_info >= (3, 11): + from importlib._bootstrap_external import NamespaceLoader as NamespaceLoader +if sys.version_info >= (3, 14): + from importlib._bootstrap_external import AppleFrameworkLoader as AppleFrameworkLoader + +def all_suffixes() -> list[str]: ... + +if sys.version_info >= (3, 14): + __all__ = [ + "AppleFrameworkLoader", + "BYTECODE_SUFFIXES", + "BuiltinImporter", + "DEBUG_BYTECODE_SUFFIXES", + "EXTENSION_SUFFIXES", + "ExtensionFileLoader", + "FileFinder", + "FrozenImporter", + "ModuleSpec", + "NamespaceLoader", + "OPTIMIZED_BYTECODE_SUFFIXES", + "PathFinder", + "SOURCE_SUFFIXES", + "SourceFileLoader", + "SourcelessFileLoader", + "WindowsRegistryFinder", + "all_suffixes", + ] diff --git a/src/puyapy/awst_build/arc4_decorators.py b/src/puyapy/awst_build/arc4_decorators.py index accfde248c..260fa01bc0 100644 --- a/src/puyapy/awst_build/arc4_decorators.py +++ b/src/puyapy/awst_build/arc4_decorators.py @@ -181,7 +181,13 @@ def require_arg_name(arg: pytypes.FuncArg) -> str: ) return arg.name - result = {require_arg_name(arg): arg.type for arg in func_type.args} + if not func_type.args[0].type.is_type_or_subtype( + pytypes.ARC4ClientBaseType, pytypes.ARC4ContractBaseType + ): + raise InternalError(f"expected a self parameter for {func_type.name}") + args = func_type.args[1:] + + result = {require_arg_name(arg): arg.type for arg in args} if "output" in result: # https://github.com/algorandfoundation/ARCs/blob/main/assets/arc-0032/application.schema.json raise CodeError( diff --git a/src/puyapy/awst_build/context.py b/src/puyapy/awst_build/context.py index 1a9158763c..9af50b3cc6 100644 --- a/src/puyapy/awst_build/context.py +++ b/src/puyapy/awst_build/context.py @@ -188,9 +188,6 @@ def function_pytype( ): arg_pytype = type_to_pytype(registry, at, source_location=loc, in_func_sig=True) func_args.append(pytypes.FuncArg(type=arg_pytype, kind=kind, name=name)) - # is the function a method but not a static method? if so, drop the first (implicit) argument - if func_def.info and not func_def.is_static: - _self_arg, *func_args = func_args return pytypes.FuncType( name=func_def.fullname, args=func_args, diff --git a/src/puyapy/awst_build/contract.py b/src/puyapy/awst_build/contract.py index feee1ee74b..d5ca92b27a 100644 --- a/src/puyapy/awst_build/contract.py +++ b/src/puyapy/awst_build/contract.py @@ -26,6 +26,7 @@ from puyapy.models import ( ARC4BareMethodData, ARC4MethodData, + ArgKind, ContractClassOptions, ContractFragmentBase, ContractFragmentMethod, @@ -330,6 +331,7 @@ def visit_function( ctx, func_def=func_def, source_location=source_location, + is_method=True, inline=inline, contract_method_info=ContractMethodInfo( fragment=self.fragment, @@ -440,9 +442,10 @@ def add_stub_method( *, return_type: pytypes.RuntimeType = pytypes.BoolType, ) -> None: + self_arg = pytypes.FuncArg(pytypes.ContractBaseType, "self", ArgKind.ARG_POS) self.symbols[name] = pytypes.FuncType( name=".".join((self.id, name)), - args=(), + args=(self_arg,), ret_type=return_type, ) implementation = awst_nodes.ContractMethod( diff --git a/src/puyapy/awst_build/eb/arc4/struct.py b/src/puyapy/awst_build/eb/arc4/struct.py index 2c964ea0c3..715eabbce9 100644 --- a/src/puyapy/awst_build/eb/arc4/struct.py +++ b/src/puyapy/awst_build/eb/arc4/struct.py @@ -3,7 +3,7 @@ from puya import log from puya.awst import wtypes -from puya.awst.nodes import Copy, Expression, FieldExpression, NewStruct +from puya.awst.nodes import Copy, Expression, FieldExpression, NewStruct, SubroutineID from puya.parse import SourceLocation from puyapy import models from puyapy.awst_build import pytypes @@ -23,6 +23,10 @@ from puyapy.awst_build.eb.arc4._base import ARC4FromLogBuilder from puyapy.awst_build.eb.factories import builder_for_instance from puyapy.awst_build.eb.interface import BuilderComparisonOp, InstanceBuilder, NodeBuilder +from puyapy.awst_build.eb.subroutine import ( + BoundSubroutineInvokerExpressionBuilder, + SubroutineInvokerExpressionBuilder, +) from puyapy.awst_build.utils import get_arg_mapping logger = log.get_logger(__name__) @@ -68,6 +72,15 @@ def member_access(self, name: str, location: SourceLocation) -> NodeBuilder: case "from_log": return ARC4FromLogBuilder(location, self.produces()) case _: + pytype = self.produces() + method = pytype.static_methods.get(name) or pytype.methods.get(name) + if method: + return SubroutineInvokerExpressionBuilder( + target=SubroutineID(method.name), + func_type=method, + location=location, + ) + return super().member_access(name, location) @@ -89,6 +102,21 @@ def member_access(self, name: str, location: SourceLocation) -> NodeBuilder: source_location=location, ) return builder_for_instance(field, result_expr) + case method_name if method := self.pytype.methods.get(method_name): + return BoundSubroutineInvokerExpressionBuilder( + target=SubroutineID(method.name), + func_type=method, + location=location, + args=[self], + arg_names=[None], + arg_kinds=[models.ArgKind.ARG_POS], + ) + case method_name if static_method := self.pytype.static_methods.get(method_name): + return SubroutineInvokerExpressionBuilder( + target=SubroutineID(static_method.name), + func_type=static_method, + location=location, + ) case "copy": return CopyBuilder(self.resolve(), location, self.pytype) case "_replace": diff --git a/src/puyapy/awst_build/eb/contracts.py b/src/puyapy/awst_build/eb/contracts.py index c4ef30e453..beb124fd3f 100644 --- a/src/puyapy/awst_build/eb/contracts.py +++ b/src/puyapy/awst_build/eb/contracts.py @@ -26,7 +26,7 @@ ) from puyapy.awst_build.eb.subroutine import ( BaseClassSubroutineInvokerExpressionBuilder, - SubroutineInvokerExpressionBuilder, + BoundSubroutineInvokerExpressionBuilder, ) from puyapy.models import ContractFragmentBase @@ -56,18 +56,11 @@ def call( @typing.override def member_access(self, name: str, location: SourceLocation) -> NodeBuilder: - sym_type = self.fragment.resolve_symbol(name) - if sym_type is None: + func_type = self.fragment.resolve_symbol(name) + if func_type is None: return super().member_access(name, location) - if not isinstance(sym_type, pytypes.FuncType): + if not isinstance(func_type, pytypes.FuncType): raise CodeError("static references are only supported for methods", location) - func_type = attrs.evolve( - sym_type, - args=[ - pytypes.FuncArg(type=self.produces(), name=None, kind=models.ArgKind.ARG_POS), - *sym_type.args, - ], - ) method = self.fragment.resolve_method(name) if method is None: raise CodeError("unable to resolve method member", location) @@ -98,10 +91,13 @@ def member_access(self, name: str, location: SourceLocation) -> NodeBuilder: if sym_type is None: raise CodeError(f"unrecognised member of {self.pytype}: {name}", location) if isinstance(sym_type, pytypes.FuncType): - return SubroutineInvokerExpressionBuilder( + return BoundSubroutineInvokerExpressionBuilder( target=InstanceMethodTarget(member_name=name), func_type=sym_type, location=location, + args=[self], + arg_names=[None], + arg_kinds=[models.ArgKind.ARG_POS], ) else: storage = self._fragment.resolve_storage(name) diff --git a/src/puyapy/awst_build/eb/native/struct.py b/src/puyapy/awst_build/eb/native/struct.py index 6472612816..7baad54ecc 100644 --- a/src/puyapy/awst_build/eb/native/struct.py +++ b/src/puyapy/awst_build/eb/native/struct.py @@ -3,7 +3,7 @@ from puya import log from puya.awst import wtypes -from puya.awst.nodes import Copy, Expression, FieldExpression, NewStruct +from puya.awst.nodes import Copy, Expression, FieldExpression, NewStruct, SubroutineID from puya.parse import SourceLocation from puyapy import models from puyapy.awst_build import pytypes @@ -27,6 +27,10 @@ NodeBuilder, TypeBuilder, ) +from puyapy.awst_build.eb.subroutine import ( + BoundSubroutineInvokerExpressionBuilder, + SubroutineInvokerExpressionBuilder, +) from puyapy.awst_build.utils import get_arg_mapping logger = log.get_logger(__name__) @@ -67,6 +71,18 @@ def call( expr = NewStruct(wtype=pytype.wtype, values=values, source_location=location) return StructExpressionBuilder(expr, pytype) + def member_access(self, name: str, location: SourceLocation) -> NodeBuilder: + pytype = self.produces() + method = pytype.static_methods.get(name) or pytype.methods.get(name) + if method: + return SubroutineInvokerExpressionBuilder( + target=SubroutineID(method.name), + func_type=method, + location=location, + ) + + return super().member_access(name, location) + class StructExpressionBuilder( NotIterableInstanceExpressionBuilder[pytypes.StructType], @@ -91,6 +107,21 @@ def member_access(self, name: str, location: SourceLocation) -> NodeBuilder: source_location=location, ) return builder_for_instance(field, result_expr) + case method_name if method := self.pytype.methods.get(method_name): + return BoundSubroutineInvokerExpressionBuilder( + target=SubroutineID(method.name), + func_type=method, + location=location, + args=[self], + arg_names=[None], + arg_kinds=[models.ArgKind.ARG_POS], + ) + case method_name if static_method := self.pytype.static_methods.get(method_name): + return SubroutineInvokerExpressionBuilder( + target=SubroutineID(static_method.name), + func_type=static_method, + location=location, + ) case "copy": return CopyBuilder(self.resolve(), location, self.pytype) case "_replace": diff --git a/src/puyapy/awst_build/eb/subroutine.py b/src/puyapy/awst_build/eb/subroutine.py index b753517364..7dee30184d 100644 --- a/src/puyapy/awst_build/eb/subroutine.py +++ b/src/puyapy/awst_build/eb/subroutine.py @@ -107,7 +107,7 @@ def call( return dummy_value(result_pytyp, location) arg = arg_map[arg_map_name] - if pytypes.ContractBaseType < arg_typ: + if pytypes.ContractBaseType <= arg_typ: if not (arg_typ <= arg.pytype): logger.error("unexpected argument type", location=arg.source_location) else: @@ -124,6 +124,37 @@ def call( return builder_for_instance(result_pytyp, call_expr) +class BoundSubroutineInvokerExpressionBuilder(SubroutineInvokerExpressionBuilder): + def __init__( + self, + target: SubroutineTarget, + func_type: pytypes.FuncType, + location: SourceLocation, + args: Sequence[NodeBuilder], + arg_kinds: list[models.ArgKind], + arg_names: list[str | None], + ): + super().__init__(target, func_type, location) + assert len(args) == len(arg_kinds) == len(arg_names) + self.bound_args = args + self.bound_arg_kinds = arg_kinds + self.bound_arg_names = arg_names + + def call( + self, + args: Sequence[NodeBuilder], + arg_kinds: list[models.ArgKind], + arg_names: list[str | None], + location: SourceLocation, + ) -> InstanceBuilder: + return super().call( + args=(*self.bound_args, *args), + arg_kinds=self.bound_arg_kinds + arg_kinds, + arg_names=self.bound_arg_names + arg_names, + location=location, + ) + + class BaseClassSubroutineInvokerExpressionBuilder(SubroutineInvokerExpressionBuilder): def __init__( self, diff --git a/src/puyapy/awst_build/eb/tuple.py b/src/puyapy/awst_build/eb/tuple.py index 123a87026c..c1a98b16e9 100644 --- a/src/puyapy/awst_build/eb/tuple.py +++ b/src/puyapy/awst_build/eb/tuple.py @@ -16,6 +16,7 @@ NamedTupleExpression, SliceExpression, Statement, + SubroutineID, TupleExpression, TupleItemExpression, UInt64Constant, @@ -45,6 +46,10 @@ StaticSizedCollectionBuilder, TypeBuilder, ) +from puyapy.awst_build.eb.subroutine import ( + BoundSubroutineInvokerExpressionBuilder, + SubroutineInvokerExpressionBuilder, +) from puyapy.awst_build.utils import get_arg_mapping, tuple_iterable_item_type logger = log.get_logger(__name__) @@ -149,6 +154,15 @@ def call( return TupleExpressionBuilder(expr, pytype) def member_access(self, name: str, location: SourceLocation) -> NodeBuilder: + pytype = self.produces() + method = pytype.static_methods.get(name) or pytype.methods.get(name) + if method: + return SubroutineInvokerExpressionBuilder( + target=SubroutineID(method.name), + func_type=method, + location=location, + ) + if name in _NAMED_TUPLE_CLASS_MEMBERS: raise CodeError("unsupported member access", location) return super().member_access(name, location) @@ -323,6 +337,21 @@ def member_access(self, name: str, location: SourceLocation) -> NodeBuilder: elif name in _NAMED_TUPLE_CLASS_MEMBERS: type_builder = NamedTupleTypeBuilder(self.pytype, self.source_location) return type_builder.member_access(name, location) + elif method := self.pytype.methods.get(name): + return BoundSubroutineInvokerExpressionBuilder( + target=SubroutineID(method.name), + func_type=method, + location=location, + args=[self], + arg_names=[None], + arg_kinds=[models.ArgKind.ARG_POS], + ) + elif static_method := self.pytype.static_methods.get(name): + return SubroutineInvokerExpressionBuilder( + target=SubroutineID(static_method.name), + func_type=static_method, + location=location, + ) if name in _TUPLE_MEMBERS: raise CodeError("unsupported member access", location) raise CodeError("unrecognised member access", location) diff --git a/src/puyapy/awst_build/module.py b/src/puyapy/awst_build/module.py index 4b8efd1612..6a3daabb79 100644 --- a/src/puyapy/awst_build/module.py +++ b/src/puyapy/awst_build/module.py @@ -9,6 +9,7 @@ from puya.algo_constants import MAX_SCRATCH_SLOT_NUMBER from puya.awst.nodes import AWST, LogicSignature, RootNode, StateTotals from puya.errors import CodeError, InternalError +from puya.parse import SourceLocation from puya.program_refs import LogicSigReference from puya.utils import coalesce from puyapy import code_fixes @@ -105,7 +106,7 @@ def visit_function( def deferred(ctx: ASTConversionModuleContext) -> RootNode: program = FunctionASTConverter.convert( - ctx, func_def, source_location, inline=False + ctx, func_def, source_location, is_method=False, inline=False ) ctx.register_pytype(pytypes.LogicSigType, alias=func_def.fullname) return LogicSignature( @@ -140,7 +141,12 @@ def deferred(ctx: ASTConversionModuleContext) -> RootNode: return [ lambda ctx: FunctionASTConverter.convert( - ctx, func_def, source_location, inline=inline, pure=internal_pure_dec is not None + ctx, + func_def, + source_location, + is_method=False, + inline=inline, + pure=internal_pure_dec is not None, ) ] @@ -697,6 +703,12 @@ def _process_dataclass_like_fields( pass case mypy.nodes.PassStmt(): pass + case mypy.nodes.FuncDef(): + # A later pass once we have our fields in place will process struct methods + pass + case mypy.nodes.Decorator(): + # A later pass once we have our fields in place will process struct methods + pass case _: logger.error( f"unsupported syntax for {base_type} member declaration", location=stmt_loc @@ -705,6 +717,67 @@ def _process_dataclass_like_fields( return fields if not has_error else None +def _process_dataclass_like_methods( + context: ASTConversionModuleContext, cdef: mypy.nodes.ClassDef +) -> tuple[StatementResult, dict[str, pytypes.FuncType], dict[str, pytypes.FuncType]]: + method_routines: StatementResult = [] + methods: dict[str, pytypes.FuncType] = {} + static_methods: dict[str, pytypes.FuncType] = {} + + def handle_function_definition( + func_def: mypy.nodes.FuncDef, + decorator: mypy.nodes.Decorator | None, + location: SourceLocation, + ) -> None: + method_name = func_def.name + if method_name.startswith("__") and method_name.endswith("__"): + raise CodeError( + "methods starting and ending with a double underscore" + ' (aka "dunder" methods) are reserved for the Python data model' + " (https://docs.python.org/3/reference/datamodel.html)." + " These methods are not supported in dataclasses " + "(typing.namedtuple, algopy.struct, algopy.arc4.struct)", + location, + ) + + if func_def.is_class: + logger.error("@classmethod is not supported inside dataclasses") + + dec_by_fullname = get_decorators_by_fullname(context, decorator) if decorator else {} + subroutine_dec = dec_by_fullname.pop(constants.SUBROUTINE_HINT, None) + inline = None + if subroutine_dec is not None: + inline = get_subroutine_decorator_inline_arg(context, subroutine_dec) + for _ in dec_by_fullname.values(): + logger.error("unsupported struct method decorator", location=location) + + if func_def.is_static: + static_methods[method_name] = context.function_pytype(func_def) + else: + methods[method_name] = context.function_pytype(func_def) + + method_routines.append( + lambda ctx: FunctionASTConverter.convert( + ctx, func_def, location, is_method=True, inline=inline + ) + ) + + for stmt in cdef.defs.body: + stmt_loc = context.node_location(stmt) + match stmt: + case mypy.nodes.SymbolNode(name=symbol_name) if ( + cdef.info.names[symbol_name].plugin_generated + ): + pass + case mypy.nodes.FuncDef(): + handle_function_definition(stmt, None, stmt_loc) + case mypy.nodes.Decorator(): + handle_function_definition(stmt.func, stmt, stmt_loc) + case _: + pass + return method_routines, methods, static_methods + + def _process_struct( context: ASTConversionModuleContext, base: pytypes.PyType, cdef: mypy.nodes.ClassDef ) -> StatementResult: @@ -723,7 +796,10 @@ def _process_struct( source_location=cls_loc, ) context.register_pytype(struct_typ) - return [] + method_routines, methods, static_methods = _process_dataclass_like_methods(context, cdef) + struct_typ.methods.update(methods) + struct_typ.static_methods.update(static_methods) + return method_routines def _process_named_tuple( @@ -740,7 +816,10 @@ def _process_named_tuple( source_location=cls_loc, ) context.register_pytype(named_tuple_type) - return [] + method_routines, methods, static_methods = _process_dataclass_like_methods(context, cdef) + named_tuple_type.methods.update(methods) + named_tuple_type.static_methods.update(static_methods) + return method_routines def _map_scratch_space_reservation( diff --git a/src/puyapy/awst_build/pytypes.py b/src/puyapy/awst_build/pytypes.py index 29cd097c9d..2b324a9795 100644 --- a/src/puyapy/awst_build/pytypes.py +++ b/src/puyapy/awst_build/pytypes.py @@ -362,6 +362,8 @@ class NamedTupleType(TupleType, RuntimeType): mro: tuple[PyType, ...] = attrs.field(default=(NamedTupleBaseType,), init=False) desc: str | None = None wtype: wtypes.WTuple = attrs.field(init=False) + methods: dict[str, FuncType] = attrs.field(eq=False, factory=dict) + static_methods: dict[str, FuncType] = attrs.field(eq=False, factory=dict) @items.default def _items(self) -> tuple[PyType, ...]: @@ -481,6 +483,8 @@ class StructType(RuntimeType): source_location: SourceLocation | None = attrs.field(eq=False) generic: None = None desc: str | None = None + methods: dict[str, FuncType] = attrs.field(eq=False, factory=dict) + static_methods: dict[str, FuncType] = attrs.field(eq=False, factory=dict) @cached_property def names(self) -> tuple[str, ...]: diff --git a/src/puyapy/awst_build/subroutine.py b/src/puyapy/awst_build/subroutine.py index 660144fecc..34f9d510b5 100644 --- a/src/puyapy/awst_build/subroutine.py +++ b/src/puyapy/awst_build/subroutine.py @@ -76,7 +76,10 @@ StorageProxyConstructorResult, ) from puyapy.awst_build.eb.logicsig import LogicSigExpressionBuilder -from puyapy.awst_build.eb.subroutine import SubroutineInvokerExpressionBuilder +from puyapy.awst_build.eb.subroutine import ( + BoundSubroutineInvokerExpressionBuilder, + SubroutineInvokerExpressionBuilder, +) from puyapy.awst_build.utils import ( extract_bytes_literal_from_mypy, get_decorators_by_fullname, @@ -556,6 +559,7 @@ def __init__( contract_method_info: ContractMethodInfo | None, source_location: SourceLocation, *, + is_method: bool, inline: bool | None, pure: bool | None, ): @@ -587,7 +591,7 @@ def __init__( # check & convert the arguments mypy_args = func_def.arguments mypy_arg_types = type_info.arg_types - if contract_method_info is not None: + if is_method and not func_def.is_static: # function is a method if not mypy_args: logger.error("method declaration is missing 'self' argument", location=func_loc) @@ -597,18 +601,29 @@ def __init__( "if function is a method, first variable should be self-like", func_loc, ) - mypy_args = mypy_args[1:] - mypy_arg_types = mypy_arg_types[1:] + if contract_method_info is not None: + mypy_args = mypy_args[1:] + mypy_arg_types = mypy_arg_types[1:] elif mypy_args: + self._precondition( + contract_method_info is None, + "if a function is not a method, it shouldn't be bound to a contract", + func_loc, + ) self._precondition( not mypy_args[0].variable.is_self, - "if function is not a method, first variable should be self-like", + "if function is not a method, first variable should not be self-like", func_loc, ) + self._self_var_name: str | None = None self._symtable = dict[str, pytypes.PyType]() args = list[SubroutineArgument]() for arg, arg_type in zip(mypy_args, mypy_arg_types, strict=True): - arg_loc = context.node_location(arg) + if arg.variable.is_self: + arg_loc = source_location + self._self_var_name = arg.variable.name + else: + arg_loc = context.node_location(arg) if arg.kind.is_star(): raise CodeError("variadic functions are not supported", arg_loc) if arg.initializer is not None: @@ -659,6 +674,7 @@ def convert( func_def: mypy.nodes.FuncDef, source_location: SourceLocation, *, + is_method: bool, inline: bool | None, pure: bool = False, ) -> Subroutine: ... @@ -672,6 +688,7 @@ def convert( source_location: SourceLocation, contract_method_info: ContractMethodInfo, *, + is_method: bool, inline: bool | None, ) -> ContractMethod: ... @@ -683,6 +700,7 @@ def convert( source_location: SourceLocation, contract_method_info: ContractMethodInfo | None = None, *, + is_method: bool, inline: bool | None, pure: bool | None = None, ) -> Subroutine | ContractMethod: @@ -692,18 +710,33 @@ def convert( contract_method_info=contract_method_info, inline=inline, pure=pure, + is_method=is_method, source_location=source_location, ).result @typing.override def builder_for_self(self, expr_loc: SourceLocation) -> NodeBuilder: - if self.contract_method_info is None: - raise InternalError("variable is inferred as self outside of contract scope", expr_loc) - return ContractSelfExpressionBuilder( - fragment=self.contract_method_info.fragment, - pytype=self.contract_method_info.contract_type, - location=expr_loc, + if self.contract_method_info is not None: + return ContractSelfExpressionBuilder( + fragment=self.contract_method_info.fragment, + pytype=self.contract_method_info.contract_type, + location=expr_loc, + ) + + # NOTE: If we want to allow __init__ then we should special case it in some way :) + if self._self_var_name is None: + raise InternalError("tried to resolve self on method with no detected self variable") + + self_type = self.resolve_local_type(self._self_var_name, expr_loc) + if self_type is None: + raise InternalError("could not resolve type of self variable", expr_loc) + + var_expr = VarExpression( + name=self._self_var_name, + wtype=self_type.checked_wtype(expr_loc), + source_location=expr_loc, ) + return builder_for_instance(self_type, var_expr) @typing.override def resolve_local_type(self, var_name: str, expr_loc: SourceLocation) -> pytypes.PyType | None: @@ -773,8 +806,14 @@ def visit_super_expr(self, super_expr: mypy.nodes.SuperExpr) -> NodeBuilder: ) super_target = InstanceSuperMethodTarget(member_name=super_expr.name) - return SubroutineInvokerExpressionBuilder( - target=super_target, func_type=func_type, location=super_loc + super_self = self.builder_for_self(super_loc) + return BoundSubroutineInvokerExpressionBuilder( + target=super_target, + func_type=func_type, + location=super_loc, + args=[super_self], + arg_names=[None], + arg_kinds=[models.ArgKind.ARG_POS], ) # statements diff --git a/test_cases/structure_methods/contract.py b/test_cases/structure_methods/contract.py new file mode 100644 index 0000000000..05b33c17cb --- /dev/null +++ b/test_cases/structure_methods/contract.py @@ -0,0 +1,108 @@ +import typing + +from algopy import ARC4Contract, Struct, UInt64, arc4, public, subroutine + + +class ARC4TestStruct(arc4.Struct): + value: arc4.UInt64 + + def return_value_times(self, times: UInt64) -> UInt64: + return self.value.as_uint64() * times + + @staticmethod + def return1() -> UInt64: + return UInt64(1) + + +class TestStruct(Struct): + value: UInt64 + + def return_value_times(self, times: UInt64) -> UInt64: + return self.value * times + + @staticmethod + def return1() -> UInt64: + return UInt64(1) + + +class TestNamedTuple(typing.NamedTuple): + value: UInt64 + + def return_value_times(self, times: UInt64) -> UInt64: + return self.value * times + + @staticmethod + def return1() -> UInt64: + return UInt64(1) + + +class GroupedMethods(typing.NamedTuple): + @subroutine(inline=False) + def never_inlined_usually_inlined(self, v: UInt64) -> UInt64: + return v + UInt64(1) + + @subroutine(inline=True) + def always_inlined_not_usually_inlined(self, v: UInt64) -> None: + arc4.emit(ARC4TestStruct(arc4.UInt64(v))) + arc4.emit(ARC4TestStruct(arc4.UInt64(v))) + arc4.emit(ARC4TestStruct(arc4.UInt64(v))) + arc4.emit(ARC4TestStruct(arc4.UInt64(v))) + arc4.emit(ARC4TestStruct(arc4.UInt64(v))) + arc4.emit(ARC4TestStruct(arc4.UInt64(v))) + arc4.emit(ARC4TestStruct(arc4.UInt64(v))) + arc4.emit(ARC4TestStruct(arc4.UInt64(v))) + + def usually_inlined(self, v: UInt64) -> UInt64: + return v + UInt64(1) + + def not_usually_inlined(self, v: UInt64) -> None: + arc4.emit(ARC4TestStruct(arc4.UInt64(v))) + arc4.emit(ARC4TestStruct(arc4.UInt64(v))) + arc4.emit(ARC4TestStruct(arc4.UInt64(v))) + arc4.emit(ARC4TestStruct(arc4.UInt64(v))) + arc4.emit(ARC4TestStruct(arc4.UInt64(v))) + arc4.emit(ARC4TestStruct(arc4.UInt64(v))) + arc4.emit(ARC4TestStruct(arc4.UInt64(v))) + arc4.emit(ARC4TestStruct(arc4.UInt64(v))) + + +class TestContract(ARC4Contract): + @public + def test(self) -> None: + # Call instance methods from instance side + assert UInt64(18) == ARC4TestStruct(arc4.UInt64(9)).return_value_times(UInt64(2)) + assert UInt64(18) == TestStruct(UInt64(9)).return_value_times(UInt64(2)) + assert UInt64(18) == TestNamedTuple(UInt64(9)).return_value_times(UInt64(2)) + + # Call instance methods from class side + assert UInt64(18) == ARC4TestStruct.return_value_times( + ARC4TestStruct(arc4.UInt64(9)), UInt64(2) + ) + assert UInt64(18) == TestStruct.return_value_times(TestStruct(UInt64(9)), UInt64(2)) + assert UInt64(18) == TestNamedTuple.return_value_times( + TestNamedTuple(UInt64(9)), UInt64(2) + ) + + # Call static methods from class side + assert UInt64(1) == ARC4TestStruct.return1() + assert UInt64(1) == TestStruct.return1() + assert UInt64(1) == TestNamedTuple.return1() + + # Call static methods from instance side + assert UInt64(1) == ARC4TestStruct(arc4.UInt64(0)).return1() + assert UInt64(1) == TestStruct(UInt64(0)).return1() + assert UInt64(1) == TestNamedTuple(UInt64(0)).return1() + + # Every method is called twice for a simple reason: if a method is only called once it + # makes no sense to emit it separately (doing that adds callsub/proto/retsub machinery and + # limits the ability of our optimizer). + # Calling a method twice forces the optimizer to decide if the contract-size wins outweigh + # the function-calling ceremony. + assert UInt64(3) == GroupedMethods().never_inlined_usually_inlined(UInt64(2)) + assert UInt64(3) == GroupedMethods().never_inlined_usually_inlined(UInt64(2)) + assert UInt64(3) == GroupedMethods().usually_inlined(UInt64(2)) + assert UInt64(3) == GroupedMethods().usually_inlined(UInt64(2)) + GroupedMethods().always_inlined_not_usually_inlined(UInt64(2)) + GroupedMethods().always_inlined_not_usually_inlined(UInt64(2)) + GroupedMethods().not_usually_inlined(UInt64(2)) + GroupedMethods().not_usually_inlined(UInt64(2)) diff --git a/test_cases/structure_methods/out/TestContract.approval.puya.map b/test_cases/structure_methods/out/TestContract.approval.puya.map new file mode 100644 index 0000000000..e8bd6a3c62 --- /dev/null +++ b/test_cases/structure_methods/out/TestContract.approval.puya.map @@ -0,0 +1,643 @@ +{ + "version": 3, + "sources": [ + "../contract.py" + ], + "mappings": ";;;;;;;;;;;;;;;;;;;;;AAoEA;;AAAA;;;AAAA;;;;;;AAAA;;;AAAA;;;;AAAA;AACK;;AAAA;AAAA;;AAAA;AAAA;AAAA;;;;;;;;;;;AA9BA;;;AAEU;;AAAI;AAAJ;AAAP;AAgBJ;;;AAC6B;;AAAA;AAAzB;;;;;;AAAA;AAAA;AAAA;AAAA;AACA;AAAA;AACA;AAAA;AACA;AAAA;AACA;AAAA;AACA;AAAA;AACA;AAAA;AACA;;AAmCmE;AAA/C;;;AAAb;AAAA;AAAP;AACmE;AAA/C;;;AAAb;AAAA;AAAP;AAxDA;AAAA;AAAA;AACA;AADA;AAEA;AAFA;AAGA;AAHA;AAIA;AAJA;AAKA;AALA;AAMA;AANA;AAOA;AAPA;AAAA;AAAA;AACA;AADA;AAEA;AAFA;AAGA;AAHA;AAIA;AAJA;AAKA;AALA;AAMA;AANA;AAOA;AAsDqC;AAArC;;;AACqC;AAArC;;;AAtCH;AAAA", + "op_pc_offset": 0, + "pc_events": { + "1": { + "subroutine": "algopy.arc4.ARC4Contract.approval_program", + "params": {}, + "block": "main", + "stack_in": [], + "op": "intcblock 2 1 3" + }, + "6": { + "op": "bytecblock 0xed3267e80000000000000002" + }, + "21": { + "op": "txn NumAppArgs", + "defined_out": [ + "tmp%0#1" + ], + "stack_out": [ + "tmp%0#1" + ] + }, + "23": { + "op": "bz main___algopy_default_create@5", + "stack_out": [] + }, + "26": { + "op": "pushbytes 0xa78000de // method \"test()void\"", + "defined_out": [ + "Method(test()void)" + ], + "stack_out": [ + "Method(test()void)" + ] + }, + "32": { + "op": "txna ApplicationArgs 0", + "defined_out": [ + "Method(test()void)", + "tmp%2#0" + ], + "stack_out": [ + "Method(test()void)", + "tmp%2#0" + ] + }, + "35": { + "op": "match main_test_route@3", + "stack_out": [] + }, + "39": { + "op": "err" + }, + "40": { + "block": "main_test_route@3", + "stack_in": [], + "op": "txn OnCompletion", + "defined_out": [ + "tmp%3#0" + ], + "stack_out": [ + "tmp%3#0" + ] + }, + "42": { + "op": "!", + "defined_out": [ + "tmp%4#0" + ], + "stack_out": [ + "tmp%4#0" + ] + }, + "43": { + "op": "txn ApplicationID", + "defined_out": [ + "tmp%4#0", + "tmp%5#0" + ], + "stack_out": [ + "tmp%4#0", + "tmp%5#0" + ] + }, + "45": { + "op": "&&", + "defined_out": [ + "tmp%7#0" + ], + "stack_out": [ + "tmp%7#0" + ] + }, + "46": { + "op": "assert", + "stack_out": [] + }, + "47": { + "op": "b test" + }, + "50": { + "block": "main___algopy_default_create@5", + "stack_in": [], + "op": "txn OnCompletion", + "defined_out": [ + "tmp%8#0" + ], + "stack_out": [ + "tmp%8#0" + ] + }, + "52": { + "op": "!", + "defined_out": [ + "tmp%9#0" + ], + "stack_out": [ + "tmp%9#0" + ] + }, + "53": { + "op": "txn ApplicationID", + "defined_out": [ + "tmp%10#0", + "tmp%9#0" + ], + "stack_out": [ + "tmp%9#0", + "tmp%10#0" + ] + }, + "55": { + "op": "!", + "defined_out": [ + "tmp%11#0", + "tmp%9#0" + ], + "stack_out": [ + "tmp%9#0", + "tmp%11#0" + ] + }, + "56": { + "op": "&&", + "defined_out": [ + "tmp%12#0" + ], + "stack_out": [ + "tmp%12#0" + ] + }, + "57": { + "op": "return", + "defined_out": [], + "stack_out": [] + }, + "58": { + "subroutine": "test_cases.structure_methods.contract.GroupedMethods.never_inlined_usually_inlined", + "params": { + "v#0": "uint64" + }, + "block": "never_inlined_usually_inlined", + "stack_in": [], + "op": "proto 1 1" + }, + "61": { + "op": "frame_dig -1", + "defined_out": [ + "v#0 (copy)" + ], + "stack_out": [ + "v#0 (copy)" + ] + }, + "63": { + "op": "intc_1 // 1", + "defined_out": [ + "1", + "v#0 (copy)" + ], + "stack_out": [ + "v#0 (copy)", + "1" + ] + }, + "64": { + "op": "+", + "defined_out": [ + "tmp%0#0" + ], + "stack_out": [ + "tmp%0#0" + ] + }, + "65": { + "retsub": true, + "op": "retsub" + }, + "66": { + "subroutine": "test_cases.structure_methods.contract.GroupedMethods.not_usually_inlined", + "params": { + "v#0": "uint64" + }, + "block": "not_usually_inlined", + "stack_in": [], + "op": "proto 1 0" + }, + "69": { + "op": "frame_dig -1", + "defined_out": [ + "v#0 (copy)" + ], + "stack_out": [ + "v#0 (copy)" + ] + }, + "71": { + "op": "itob", + "defined_out": [ + "aggregate%val_as_bytes%0#0" + ], + "stack_out": [ + "aggregate%val_as_bytes%0#0" + ] + }, + "72": { + "op": "pushbytes 0xed3267e8 // method \"ARC4TestStruct(uint64)\"", + "defined_out": [ + "Method(ARC4TestStruct(uint64))", + "aggregate%val_as_bytes%0#0" + ], + "stack_out": [ + "aggregate%val_as_bytes%0#0", + "Method(ARC4TestStruct(uint64))" + ] + }, + "78": { + "op": "swap", + "stack_out": [ + "Method(ARC4TestStruct(uint64))", + "aggregate%val_as_bytes%0#0" + ] + }, + "79": { + "op": "concat", + "defined_out": [ + "event%0#0" + ], + "stack_out": [ + "event%0#0" + ] + }, + "80": { + "op": "dup", + "defined_out": [ + "event%0#0", + "event%0#0 (copy)" + ], + "stack_out": [ + "event%0#0", + "event%0#0 (copy)" + ] + }, + "81": { + "op": "log", + "stack_out": [ + "event%0#0" + ] + }, + "82": { + "op": "dup", + "stack_out": [ + "event%0#0", + "event%0#0 (copy)" + ] + }, + "83": { + "op": "log", + "stack_out": [ + "event%0#0" + ] + }, + "84": { + "op": "dup", + "stack_out": [ + "event%0#0", + "event%0#0 (copy)" + ] + }, + "85": { + "op": "log", + "stack_out": [ + "event%0#0" + ] + }, + "86": { + "op": "dup", + "stack_out": [ + "event%0#0", + "event%0#0 (copy)" + ] + }, + "87": { + "op": "log", + "stack_out": [ + "event%0#0" + ] + }, + "88": { + "op": "dup", + "stack_out": [ + "event%0#0", + "event%0#0 (copy)" + ] + }, + "89": { + "op": "log", + "stack_out": [ + "event%0#0" + ] + }, + "90": { + "op": "dup", + "stack_out": [ + "event%0#0", + "event%0#0 (copy)" + ] + }, + "91": { + "op": "log", + "stack_out": [ + "event%0#0" + ] + }, + "92": { + "op": "dup", + "stack_out": [ + "event%0#0", + "event%0#0 (copy)" + ] + }, + "93": { + "op": "log", + "stack_out": [ + "event%0#0" + ] + }, + "94": { + "op": "log", + "stack_out": [] + }, + "95": { + "retsub": true, + "op": "retsub" + }, + "96": { + "subroutine": "test_cases.structure_methods.contract.TestContract.test[routing]", + "params": {}, + "block": "test", + "stack_in": [], + "op": "intc_0 // 2", + "defined_out": [ + "2" + ], + "stack_out": [ + "2" + ] + }, + "97": { + "callsub": "test_cases.structure_methods.contract.GroupedMethods.never_inlined_usually_inlined", + "op": "callsub never_inlined_usually_inlined", + "defined_out": [ + "tmp%24#0" + ], + "stack_out": [ + "tmp%24#0" + ] + }, + "100": { + "op": "intc_2 // 3", + "defined_out": [ + "3", + "tmp%24#0" + ], + "stack_out": [ + "tmp%24#0", + "3" + ] + }, + "101": { + "op": "==", + "defined_out": [ + "tmp%25#0" + ], + "stack_out": [ + "tmp%25#0" + ] + }, + "102": { + "op": "assert", + "stack_out": [] + }, + "103": { + "op": "intc_0 // 2", + "stack_out": [ + "2" + ] + }, + "104": { + "callsub": "test_cases.structure_methods.contract.GroupedMethods.never_inlined_usually_inlined", + "op": "callsub never_inlined_usually_inlined", + "defined_out": [ + "tmp%26#0" + ], + "stack_out": [ + "tmp%26#0" + ] + }, + "107": { + "op": "intc_2 // 3", + "stack_out": [ + "tmp%26#0", + "3" + ] + }, + "108": { + "op": "==", + "defined_out": [ + "tmp%27#0" + ], + "stack_out": [ + "tmp%27#0" + ] + }, + "109": { + "op": "assert", + "stack_out": [] + }, + "110": { + "op": "bytec_0 // 0xed3267e80000000000000002", + "defined_out": [ + "0xed3267e80000000000000002" + ], + "stack_out": [ + "0xed3267e80000000000000002" + ] + }, + "111": { + "op": "log", + "stack_out": [] + }, + "112": { + "op": "bytec_0 // 0xed3267e80000000000000002", + "stack_out": [ + "0xed3267e80000000000000002" + ] + }, + "113": { + "op": "log", + "stack_out": [] + }, + "114": { + "op": "bytec_0 // 0xed3267e80000000000000002", + "stack_out": [ + "0xed3267e80000000000000002" + ] + }, + "115": { + "op": "log", + "stack_out": [] + }, + "116": { + "op": "bytec_0 // 0xed3267e80000000000000002", + "stack_out": [ + "0xed3267e80000000000000002" + ] + }, + "117": { + "op": "log", + "stack_out": [] + }, + "118": { + "op": "bytec_0 // 0xed3267e80000000000000002", + "stack_out": [ + "0xed3267e80000000000000002" + ] + }, + "119": { + "op": "log", + "stack_out": [] + }, + "120": { + "op": "bytec_0 // 0xed3267e80000000000000002", + "stack_out": [ + "0xed3267e80000000000000002" + ] + }, + "121": { + "op": "log", + "stack_out": [] + }, + "122": { + "op": "bytec_0 // 0xed3267e80000000000000002", + "stack_out": [ + "0xed3267e80000000000000002" + ] + }, + "123": { + "op": "log", + "stack_out": [] + }, + "124": { + "op": "bytec_0 // 0xed3267e80000000000000002", + "stack_out": [ + "0xed3267e80000000000000002" + ] + }, + "125": { + "op": "log", + "stack_out": [] + }, + "126": { + "op": "bytec_0 // 0xed3267e80000000000000002", + "stack_out": [ + "0xed3267e80000000000000002" + ] + }, + "127": { + "op": "log", + "stack_out": [] + }, + "128": { + "op": "bytec_0 // 0xed3267e80000000000000002", + "stack_out": [ + "0xed3267e80000000000000002" + ] + }, + "129": { + "op": "log", + "stack_out": [] + }, + "130": { + "op": "bytec_0 // 0xed3267e80000000000000002", + "stack_out": [ + "0xed3267e80000000000000002" + ] + }, + "131": { + "op": "log", + "stack_out": [] + }, + "132": { + "op": "bytec_0 // 0xed3267e80000000000000002", + "stack_out": [ + "0xed3267e80000000000000002" + ] + }, + "133": { + "op": "log", + "stack_out": [] + }, + "134": { + "op": "bytec_0 // 0xed3267e80000000000000002", + "stack_out": [ + "0xed3267e80000000000000002" + ] + }, + "135": { + "op": "log", + "stack_out": [] + }, + "136": { + "op": "bytec_0 // 0xed3267e80000000000000002", + "stack_out": [ + "0xed3267e80000000000000002" + ] + }, + "137": { + "op": "log", + "stack_out": [] + }, + "138": { + "op": "bytec_0 // 0xed3267e80000000000000002", + "stack_out": [ + "0xed3267e80000000000000002" + ] + }, + "139": { + "op": "log", + "stack_out": [] + }, + "140": { + "op": "bytec_0 // 0xed3267e80000000000000002", + "stack_out": [ + "0xed3267e80000000000000002" + ] + }, + "141": { + "op": "log", + "stack_out": [] + }, + "142": { + "op": "intc_0 // 2", + "stack_out": [ + "2" + ] + }, + "143": { + "callsub": "test_cases.structure_methods.contract.GroupedMethods.not_usually_inlined", + "op": "callsub not_usually_inlined", + "stack_out": [] + }, + "146": { + "op": "intc_0 // 2", + "stack_out": [ + "2" + ] + }, + "147": { + "callsub": "test_cases.structure_methods.contract.GroupedMethods.not_usually_inlined", + "op": "callsub not_usually_inlined", + "stack_out": [] + }, + "150": { + "op": "intc_1 // 1", + "defined_out": [ + "1" + ], + "stack_out": [ + "1" + ] + }, + "151": { + "op": "return", + "stack_out": [] + } + } +} \ No newline at end of file diff --git a/test_cases/structure_methods/out/TestContract.approval.stats.txt b/test_cases/structure_methods/out/TestContract.approval.stats.txt new file mode 100644 index 0000000000..bece23283a --- /dev/null +++ b/test_cases/structure_methods/out/TestContract.approval.stats.txt @@ -0,0 +1,10 @@ +total_bytes = 152 +total_ops = 95 +constant_bytes = 56 +constant_ops = 28 +control_flow_bytes = 22 +control_flow_ops = 7 +stack_bytes = 12 +stack_ops = 10 +other_bytes = 61 +other_ops = 50 \ No newline at end of file diff --git a/test_cases/structure_methods/out/TestContract.approval.teal b/test_cases/structure_methods/out/TestContract.approval.teal new file mode 100644 index 0000000000..d72b84ac45 --- /dev/null +++ b/test_cases/structure_methods/out/TestContract.approval.teal @@ -0,0 +1,214 @@ +#pragma version 11 +#pragma typetrack false + +// algopy.arc4.ARC4Contract.approval_program() -> uint64: +main: + intcblock 2 1 3 + bytecblock 0xed3267e80000000000000002 + // structure_methods/contract.py:69 + // class TestContract(ARC4Contract): + txn NumAppArgs + bz main___algopy_default_create@5 + pushbytes 0xa78000de // method "test()void" + txna ApplicationArgs 0 + match main_test_route@3 + err + +main_test_route@3: + // structure_methods/contract.py:70 + // @public + txn OnCompletion + ! + txn ApplicationID + && + assert + b test + +main___algopy_default_create@5: + txn OnCompletion + ! + txn ApplicationID + ! + && + return + + +// test_cases.structure_methods.contract.GroupedMethods.never_inlined_usually_inlined(v: uint64) -> uint64: +never_inlined_usually_inlined: + // structure_methods/contract.py:40-41 + // @subroutine(inline=False) + // def never_inlined_usually_inlined(self, v: UInt64) -> UInt64: + proto 1 1 + // structure_methods/contract.py:42 + // return v + UInt64(1) + frame_dig -1 + intc_1 // 1 + + + retsub + + +// test_cases.structure_methods.contract.GroupedMethods.not_usually_inlined(v: uint64) -> void: +not_usually_inlined: + // structure_methods/contract.py:58 + // def not_usually_inlined(self, v: UInt64) -> None: + proto 1 0 + // structure_methods/contract.py:59 + // arc4.emit(ARC4TestStruct(arc4.UInt64(v))) + frame_dig -1 + itob + pushbytes 0xed3267e8 // method "ARC4TestStruct(uint64)" + swap + concat + dup + log + // structure_methods/contract.py:60 + // arc4.emit(ARC4TestStruct(arc4.UInt64(v))) + dup + log + // structure_methods/contract.py:61 + // arc4.emit(ARC4TestStruct(arc4.UInt64(v))) + dup + log + // structure_methods/contract.py:62 + // arc4.emit(ARC4TestStruct(arc4.UInt64(v))) + dup + log + // structure_methods/contract.py:63 + // arc4.emit(ARC4TestStruct(arc4.UInt64(v))) + dup + log + // structure_methods/contract.py:64 + // arc4.emit(ARC4TestStruct(arc4.UInt64(v))) + dup + log + // structure_methods/contract.py:65 + // arc4.emit(ARC4TestStruct(arc4.UInt64(v))) + dup + log + // structure_methods/contract.py:66 + // arc4.emit(ARC4TestStruct(arc4.UInt64(v))) + log + retsub + + +// test_cases.structure_methods.contract.TestContract.test[routing]() -> void: +test: + // structure_methods/contract.py:96-101 + // # Every method is called twice for a simple reason: if a method is only called once it + // # makes no sense to emit it separately (doing that adds callsub/proto/retsub machinery and + // # limits the ability of our optimizer). + // # Calling a method twice forces the optimizer to decide if the contract-size wins outweigh + // # the function-calling ceremony. + // assert UInt64(3) == GroupedMethods().never_inlined_usually_inlined(UInt64(2)) + intc_0 // 2 + callsub never_inlined_usually_inlined + intc_2 // 3 + == + assert + // structure_methods/contract.py:102 + // assert UInt64(3) == GroupedMethods().never_inlined_usually_inlined(UInt64(2)) + intc_0 // 2 + callsub never_inlined_usually_inlined + intc_2 // 3 + == + assert + // structure_methods/contract.py:46 + // arc4.emit(ARC4TestStruct(arc4.UInt64(v))) + bytec_0 // 0xed3267e80000000000000002 + log + bytec_0 // 0xed3267e80000000000000002 + // structure_methods/contract.py:47 + // arc4.emit(ARC4TestStruct(arc4.UInt64(v))) + log + // structure_methods/contract.py:46 + // arc4.emit(ARC4TestStruct(arc4.UInt64(v))) + bytec_0 // 0xed3267e80000000000000002 + // structure_methods/contract.py:48 + // arc4.emit(ARC4TestStruct(arc4.UInt64(v))) + log + // structure_methods/contract.py:46 + // arc4.emit(ARC4TestStruct(arc4.UInt64(v))) + bytec_0 // 0xed3267e80000000000000002 + // structure_methods/contract.py:49 + // arc4.emit(ARC4TestStruct(arc4.UInt64(v))) + log + // structure_methods/contract.py:46 + // arc4.emit(ARC4TestStruct(arc4.UInt64(v))) + bytec_0 // 0xed3267e80000000000000002 + // structure_methods/contract.py:50 + // arc4.emit(ARC4TestStruct(arc4.UInt64(v))) + log + // structure_methods/contract.py:46 + // arc4.emit(ARC4TestStruct(arc4.UInt64(v))) + bytec_0 // 0xed3267e80000000000000002 + // structure_methods/contract.py:51 + // arc4.emit(ARC4TestStruct(arc4.UInt64(v))) + log + // structure_methods/contract.py:46 + // arc4.emit(ARC4TestStruct(arc4.UInt64(v))) + bytec_0 // 0xed3267e80000000000000002 + // structure_methods/contract.py:52 + // arc4.emit(ARC4TestStruct(arc4.UInt64(v))) + log + // structure_methods/contract.py:46 + // arc4.emit(ARC4TestStruct(arc4.UInt64(v))) + bytec_0 // 0xed3267e80000000000000002 + // structure_methods/contract.py:53 + // arc4.emit(ARC4TestStruct(arc4.UInt64(v))) + log + // structure_methods/contract.py:46 + // arc4.emit(ARC4TestStruct(arc4.UInt64(v))) + bytec_0 // 0xed3267e80000000000000002 + log + bytec_0 // 0xed3267e80000000000000002 + // structure_methods/contract.py:47 + // arc4.emit(ARC4TestStruct(arc4.UInt64(v))) + log + // structure_methods/contract.py:46 + // arc4.emit(ARC4TestStruct(arc4.UInt64(v))) + bytec_0 // 0xed3267e80000000000000002 + // structure_methods/contract.py:48 + // arc4.emit(ARC4TestStruct(arc4.UInt64(v))) + log + // structure_methods/contract.py:46 + // arc4.emit(ARC4TestStruct(arc4.UInt64(v))) + bytec_0 // 0xed3267e80000000000000002 + // structure_methods/contract.py:49 + // arc4.emit(ARC4TestStruct(arc4.UInt64(v))) + log + // structure_methods/contract.py:46 + // arc4.emit(ARC4TestStruct(arc4.UInt64(v))) + bytec_0 // 0xed3267e80000000000000002 + // structure_methods/contract.py:50 + // arc4.emit(ARC4TestStruct(arc4.UInt64(v))) + log + // structure_methods/contract.py:46 + // arc4.emit(ARC4TestStruct(arc4.UInt64(v))) + bytec_0 // 0xed3267e80000000000000002 + // structure_methods/contract.py:51 + // arc4.emit(ARC4TestStruct(arc4.UInt64(v))) + log + // structure_methods/contract.py:46 + // arc4.emit(ARC4TestStruct(arc4.UInt64(v))) + bytec_0 // 0xed3267e80000000000000002 + // structure_methods/contract.py:52 + // arc4.emit(ARC4TestStruct(arc4.UInt64(v))) + log + // structure_methods/contract.py:46 + // arc4.emit(ARC4TestStruct(arc4.UInt64(v))) + bytec_0 // 0xed3267e80000000000000002 + // structure_methods/contract.py:53 + // arc4.emit(ARC4TestStruct(arc4.UInt64(v))) + log + // structure_methods/contract.py:107 + // GroupedMethods().not_usually_inlined(UInt64(2)) + intc_0 // 2 + callsub not_usually_inlined + // structure_methods/contract.py:108 + // GroupedMethods().not_usually_inlined(UInt64(2)) + intc_0 // 2 + callsub not_usually_inlined + // structure_methods/contract.py:70 + // @public + intc_1 // 1 + return diff --git a/test_cases/structure_methods/out/TestContract.arc56.json b/test_cases/structure_methods/out/TestContract.arc56.json new file mode 100644 index 0000000000..7e59bd27e4 --- /dev/null +++ b/test_cases/structure_methods/out/TestContract.arc56.json @@ -0,0 +1,103 @@ +{ + "name": "TestContract", + "structs": {}, + "methods": [ + { + "name": "test", + "args": [], + "returns": { + "type": "void" + }, + "actions": { + "create": [], + "call": [ + "NoOp" + ] + }, + "readonly": false, + "events": [ + { + "name": "ARC4TestStruct", + "args": [ + { + "type": "uint64", + "name": "value" + } + ] + } + ], + "recommendations": {} + } + ], + "arcs": [ + 22, + 28 + ], + "networks": {}, + "state": { + "schema": { + "global": { + "ints": 0, + "bytes": 0 + }, + "local": { + "ints": 0, + "bytes": 0 + } + }, + "keys": { + "global": {}, + "local": {}, + "box": {} + }, + "maps": { + "global": {}, + "local": {}, + "box": {} + } + }, + "bareActions": { + "create": [ + "NoOp" + ], + "call": [] + }, + "sourceInfo": { + "approval": { + "sourceInfo": [], + "pcOffsetMethod": "none" + }, + "clear": { + "sourceInfo": [], + "pcOffsetMethod": "none" + } + }, + "source": { + "approval": "#pragma version 11
#pragma typetrack false

// algopy.arc4.ARC4Contract.approval_program() -> uint64:
main:
    intcblock 2 1 3
    bytecblock 0xed3267e80000000000000002
    // structure_methods/contract.py:69
    // class TestContract(ARC4Contract):
    txn NumAppArgs
    bz main___algopy_default_create@5
    pushbytes 0xa78000de // method "test()void"
    txna ApplicationArgs 0
    match main_test_route@3
    err

main_test_route@3:
    // structure_methods/contract.py:70
    // @public
    txn OnCompletion
    !
    txn ApplicationID
    &&
    assert
    b test

main___algopy_default_create@5:
    txn OnCompletion
    !
    txn ApplicationID
    !
    &&
    return


// test_cases.structure_methods.contract.GroupedMethods.never_inlined_usually_inlined(v: uint64) -> uint64:
never_inlined_usually_inlined:
    // structure_methods/contract.py:40-41
    // @subroutine(inline=False)
    // def never_inlined_usually_inlined(self, v: UInt64) -> UInt64:
    proto 1 1
    // structure_methods/contract.py:42
    // return v + UInt64(1)
    frame_dig -1
    intc_1 // 1
    +
    retsub


// test_cases.structure_methods.contract.GroupedMethods.not_usually_inlined(v: uint64) -> void:
not_usually_inlined:
    // structure_methods/contract.py:58
    // def not_usually_inlined(self, v: UInt64) -> None:
    proto 1 0
    // structure_methods/contract.py:59
    // arc4.emit(ARC4TestStruct(arc4.UInt64(v)))
    frame_dig -1
    itob
    pushbytes 0xed3267e8 // method "ARC4TestStruct(uint64)"
    swap
    concat
    dup
    log
    // structure_methods/contract.py:60
    // arc4.emit(ARC4TestStruct(arc4.UInt64(v)))
    dup
    log
    // structure_methods/contract.py:61
    // arc4.emit(ARC4TestStruct(arc4.UInt64(v)))
    dup
    log
    // structure_methods/contract.py:62
    // arc4.emit(ARC4TestStruct(arc4.UInt64(v)))
    dup
    log
    // structure_methods/contract.py:63
    // arc4.emit(ARC4TestStruct(arc4.UInt64(v)))
    dup
    log
    // structure_methods/contract.py:64
    // arc4.emit(ARC4TestStruct(arc4.UInt64(v)))
    dup
    log
    // structure_methods/contract.py:65
    // arc4.emit(ARC4TestStruct(arc4.UInt64(v)))
    dup
    log
    // structure_methods/contract.py:66
    // arc4.emit(ARC4TestStruct(arc4.UInt64(v)))
    log
    retsub


// test_cases.structure_methods.contract.TestContract.test[routing]() -> void:
test:
    // structure_methods/contract.py:96-101
    // # Every method is called twice for a simple reason: if a method is only called once it
    // # makes no sense to emit it separately (doing that adds callsub/proto/retsub machinery and
    // # limits the ability of our optimizer).
    // # Calling a method twice forces the optimizer to decide if the contract-size wins outweigh
    // # the function-calling ceremony.
    // assert UInt64(3) == GroupedMethods().never_inlined_usually_inlined(UInt64(2))
    intc_0 // 2
    callsub never_inlined_usually_inlined
    intc_2 // 3
    ==
    assert
    // structure_methods/contract.py:102
    // assert UInt64(3) == GroupedMethods().never_inlined_usually_inlined(UInt64(2))
    intc_0 // 2
    callsub never_inlined_usually_inlined
    intc_2 // 3
    ==
    assert
    // structure_methods/contract.py:46
    // arc4.emit(ARC4TestStruct(arc4.UInt64(v)))
    bytec_0 // 0xed3267e80000000000000002
    log
    bytec_0 // 0xed3267e80000000000000002
    // structure_methods/contract.py:47
    // arc4.emit(ARC4TestStruct(arc4.UInt64(v)))
    log
    // structure_methods/contract.py:46
    // arc4.emit(ARC4TestStruct(arc4.UInt64(v)))
    bytec_0 // 0xed3267e80000000000000002
    // structure_methods/contract.py:48
    // arc4.emit(ARC4TestStruct(arc4.UInt64(v)))
    log
    // structure_methods/contract.py:46
    // arc4.emit(ARC4TestStruct(arc4.UInt64(v)))
    bytec_0 // 0xed3267e80000000000000002
    // structure_methods/contract.py:49
    // arc4.emit(ARC4TestStruct(arc4.UInt64(v)))
    log
    // structure_methods/contract.py:46
    // arc4.emit(ARC4TestStruct(arc4.UInt64(v)))
    bytec_0 // 0xed3267e80000000000000002
    // structure_methods/contract.py:50
    // arc4.emit(ARC4TestStruct(arc4.UInt64(v)))
    log
    // structure_methods/contract.py:46
    // arc4.emit(ARC4TestStruct(arc4.UInt64(v)))
    bytec_0 // 0xed3267e80000000000000002
    // structure_methods/contract.py:51
    // arc4.emit(ARC4TestStruct(arc4.UInt64(v)))
    log
    // structure_methods/contract.py:46
    // arc4.emit(ARC4TestStruct(arc4.UInt64(v)))
    bytec_0 // 0xed3267e80000000000000002
    // structure_methods/contract.py:52
    // arc4.emit(ARC4TestStruct(arc4.UInt64(v)))
    log
    // structure_methods/contract.py:46
    // arc4.emit(ARC4TestStruct(arc4.UInt64(v)))
    bytec_0 // 0xed3267e80000000000000002
    // structure_methods/contract.py:53
    // arc4.emit(ARC4TestStruct(arc4.UInt64(v)))
    log
    // structure_methods/contract.py:46
    // arc4.emit(ARC4TestStruct(arc4.UInt64(v)))
    bytec_0 // 0xed3267e80000000000000002
    log
    bytec_0 // 0xed3267e80000000000000002
    // structure_methods/contract.py:47
    // arc4.emit(ARC4TestStruct(arc4.UInt64(v)))
    log
    // structure_methods/contract.py:46
    // arc4.emit(ARC4TestStruct(arc4.UInt64(v)))
    bytec_0 // 0xed3267e80000000000000002
    // structure_methods/contract.py:48
    // arc4.emit(ARC4TestStruct(arc4.UInt64(v)))
    log
    // structure_methods/contract.py:46
    // arc4.emit(ARC4TestStruct(arc4.UInt64(v)))
    bytec_0 // 0xed3267e80000000000000002
    // structure_methods/contract.py:49
    // arc4.emit(ARC4TestStruct(arc4.UInt64(v)))
    log
    // structure_methods/contract.py:46
    // arc4.emit(ARC4TestStruct(arc4.UInt64(v)))
    bytec_0 // 0xed3267e80000000000000002
    // structure_methods/contract.py:50
    // arc4.emit(ARC4TestStruct(arc4.UInt64(v)))
    log
    // structure_methods/contract.py:46
    // arc4.emit(ARC4TestStruct(arc4.UInt64(v)))
    bytec_0 // 0xed3267e80000000000000002
    // structure_methods/contract.py:51
    // arc4.emit(ARC4TestStruct(arc4.UInt64(v)))
    log
    // structure_methods/contract.py:46
    // arc4.emit(ARC4TestStruct(arc4.UInt64(v)))
    bytec_0 // 0xed3267e80000000000000002
    // structure_methods/contract.py:52
    // arc4.emit(ARC4TestStruct(arc4.UInt64(v)))
    log
    // structure_methods/contract.py:46
    // arc4.emit(ARC4TestStruct(arc4.UInt64(v)))
    bytec_0 // 0xed3267e80000000000000002
    // structure_methods/contract.py:53
    // arc4.emit(ARC4TestStruct(arc4.UInt64(v)))
    log
    // structure_methods/contract.py:107
    // GroupedMethods().not_usually_inlined(UInt64(2))
    intc_0 // 2
    callsub not_usually_inlined
    // structure_methods/contract.py:108
    // GroupedMethods().not_usually_inlined(UInt64(2))
    intc_0 // 2
    callsub not_usually_inlined
    // structure_methods/contract.py:70
    // @public
    intc_1 // 1
    return
", + "clear": "I3ByYWdtYSB2ZXJzaW9uIDExCiNwcmFnbWEgdHlwZXRyYWNrIGZhbHNlCgovLyBhbGdvcHkuYXJjNC5BUkM0Q29udHJhY3QuY2xlYXJfc3RhdGVfcHJvZ3JhbSgpIC0+IHVpbnQ2NDoKbWFpbjoKICAgIHB1c2hpbnQgMQogICAgcmV0dXJuCg==" + }, + "byteCode": { + "approval": "CyADAgEDJgEM7TJn6AAAAAAAAAACMRtBABiABKeAAN42GgCOAQABADEZFDEYEERCAC4xGRQxGBQQQ4oBAYv/IwiJigEAi/8WgATtMmfoTFBJsEmwSbBJsEmwSbBJsLCJIoj/1iQSRCKI/88kEkQosCiwKLAosCiwKLAosCiwKLAosCiwKLAosCiwKLAosCKI/7AiiP+sI0M=", + "clear": "C4EBQw==" + }, + "compilerInfo": { + "compiler": "puya", + "compilerVersion": { + "major": 99, + "minor": 99, + "patch": 99 + } + }, + "events": [ + { + "name": "ARC4TestStruct", + "args": [ + { + "type": "uint64", + "name": "value" + } + ] + } + ], + "templateVariables": {} +} \ No newline at end of file diff --git a/test_cases/structure_methods/out/TestContract.clear.puya.map b/test_cases/structure_methods/out/TestContract.clear.puya.map new file mode 100644 index 0000000000..d580b5c46b --- /dev/null +++ b/test_cases/structure_methods/out/TestContract.clear.puya.map @@ -0,0 +1,25 @@ +{ + "version": 3, + "sources": [], + "mappings": ";;;", + "op_pc_offset": 0, + "pc_events": { + "1": { + "subroutine": "algopy.arc4.ARC4Contract.clear_state_program", + "params": {}, + "block": "main", + "stack_in": [], + "op": "pushint 1", + "defined_out": [ + "1" + ], + "stack_out": [ + "1" + ] + }, + "3": { + "op": "return", + "stack_out": [] + } + } +} \ No newline at end of file diff --git a/test_cases/structure_methods/out/TestContract.clear.stats.txt b/test_cases/structure_methods/out/TestContract.clear.stats.txt new file mode 100644 index 0000000000..08e983c105 --- /dev/null +++ b/test_cases/structure_methods/out/TestContract.clear.stats.txt @@ -0,0 +1,10 @@ +total_bytes = 4 +total_ops = 2 +constant_bytes = 2 +constant_ops = 1 +control_flow_bytes = 0 +control_flow_ops = 0 +stack_bytes = 0 +stack_ops = 0 +other_bytes = 1 +other_ops = 1 \ No newline at end of file diff --git a/test_cases/structure_methods/out/TestContract.clear.teal b/test_cases/structure_methods/out/TestContract.clear.teal new file mode 100644 index 0000000000..75f539be65 --- /dev/null +++ b/test_cases/structure_methods/out/TestContract.clear.teal @@ -0,0 +1,7 @@ +#pragma version 11 +#pragma typetrack false + +// algopy.arc4.ARC4Contract.clear_state_program() -> uint64: +main: + pushint 1 + return diff --git a/test_cases/structure_methods/out/TestContract.ir/TestContract.approval.000.ssa.ir b/test_cases/structure_methods/out/TestContract.ir/TestContract.approval.000.ssa.ir new file mode 100644 index 0000000000..312fe9dcfc --- /dev/null +++ b/test_cases/structure_methods/out/TestContract.ir/TestContract.approval.000.ssa.ir @@ -0,0 +1,221 @@ +main algopy.arc4.ARC4Contract.approval_program: + block@0: // L1 + let tmp%0#0: bool = test_cases.structure_methods.contract.TestContract.__puya_arc4_router__() + return tmp%0#0 + +subroutine test_cases.structure_methods.contract.ARC4TestStruct.return_value_times(self: Encoded(uint64), times: uint64) -> : + block@0: // L9 + let self%is_original#0: bool = 1u + let self%out#0: Encoded(uint64) = self#0 + let tuple_item%0#0: Encoded(uint64) = extract_value(self#0, 0) + let tmp%0#0: uint64 = decode_bytes(tuple_item%0#0) + let tmp%1#0: uint64 = (* tmp%0#0 times#0) + return tmp%1#0 self#0 + +subroutine test_cases.structure_methods.contract.ARC4TestStruct.return1() -> uint64: + block@0: // L12 + return 1u + +subroutine test_cases.structure_methods.contract.TestStruct.return_value_times(self: Encoded(uint64), times: uint64) -> : + block@0: // L20 + let self%is_original#0: bool = 1u + let self%out#0: Encoded(uint64) = self#0 + let tuple_item%0#0: Encoded(uint64) = extract_value(self#0, 0) + let values%0#0: uint64 = decode_bytes(tuple_item%0#0) + let tmp%0#0: uint64 = (* values%0#0 times#0) + return tmp%0#0 self#0 + +subroutine test_cases.structure_methods.contract.TestStruct.return1() -> uint64: + block@0: // L23 + return 1u + +subroutine test_cases.structure_methods.contract.TestNamedTuple.return_value_times(self.value: uint64, times: uint64) -> uint64: + block@0: // L31 + let tmp%0#0: uint64 = (* self.value#0 times#0) + return tmp%0#0 + +subroutine test_cases.structure_methods.contract.TestNamedTuple.return1() -> uint64: + block@0: // L34 + return 1u + +subroutine test_cases.structure_methods.contract.GroupedMethods.never_inlined_usually_inlined(v: uint64) -> uint64: + block@0: // L40 + let tmp%0#0: uint64 = (+ v#0 1u) + return tmp%0#0 + +subroutine test_cases.structure_methods.contract.GroupedMethods.always_inlined_not_usually_inlined(v: uint64) -> void: + block@0: // L44 + let tmp%0#0: Encoded(uint64) = bytes_encode(v#0) + let tmp%1#0: Encoded(uint64) = bytes_encode<(uint64)>(tmp%0#0) + let event%0#0: bytes = (concat method "ARC4TestStruct(uint64)" tmp%1#0) + (log event%0#0) + let tmp%2#0: Encoded(uint64) = bytes_encode(v#0) + let tmp%3#0: Encoded(uint64) = bytes_encode<(uint64)>(tmp%2#0) + let event%1#0: bytes = (concat method "ARC4TestStruct(uint64)" tmp%3#0) + (log event%1#0) + let tmp%4#0: Encoded(uint64) = bytes_encode(v#0) + let tmp%5#0: Encoded(uint64) = bytes_encode<(uint64)>(tmp%4#0) + let event%2#0: bytes = (concat method "ARC4TestStruct(uint64)" tmp%5#0) + (log event%2#0) + let tmp%6#0: Encoded(uint64) = bytes_encode(v#0) + let tmp%7#0: Encoded(uint64) = bytes_encode<(uint64)>(tmp%6#0) + let event%3#0: bytes = (concat method "ARC4TestStruct(uint64)" tmp%7#0) + (log event%3#0) + let tmp%8#0: Encoded(uint64) = bytes_encode(v#0) + let tmp%9#0: Encoded(uint64) = bytes_encode<(uint64)>(tmp%8#0) + let event%4#0: bytes = (concat method "ARC4TestStruct(uint64)" tmp%9#0) + (log event%4#0) + let tmp%10#0: Encoded(uint64) = bytes_encode(v#0) + let tmp%11#0: Encoded(uint64) = bytes_encode<(uint64)>(tmp%10#0) + let event%5#0: bytes = (concat method "ARC4TestStruct(uint64)" tmp%11#0) + (log event%5#0) + let tmp%12#0: Encoded(uint64) = bytes_encode(v#0) + let tmp%13#0: Encoded(uint64) = bytes_encode<(uint64)>(tmp%12#0) + let event%6#0: bytes = (concat method "ARC4TestStruct(uint64)" tmp%13#0) + (log event%6#0) + let tmp%14#0: Encoded(uint64) = bytes_encode(v#0) + let tmp%15#0: Encoded(uint64) = bytes_encode<(uint64)>(tmp%14#0) + let event%7#0: bytes = (concat method "ARC4TestStruct(uint64)" tmp%15#0) + (log event%7#0) + return + +subroutine test_cases.structure_methods.contract.GroupedMethods.usually_inlined(v: uint64) -> uint64: + block@0: // L55 + let tmp%0#0: uint64 = (+ v#0 1u) + return tmp%0#0 + +subroutine test_cases.structure_methods.contract.GroupedMethods.not_usually_inlined(v: uint64) -> void: + block@0: // L58 + let tmp%0#0: Encoded(uint64) = bytes_encode(v#0) + let tmp%1#0: Encoded(uint64) = bytes_encode<(uint64)>(tmp%0#0) + let event%0#0: bytes = (concat method "ARC4TestStruct(uint64)" tmp%1#0) + (log event%0#0) + let tmp%2#0: Encoded(uint64) = bytes_encode(v#0) + let tmp%3#0: Encoded(uint64) = bytes_encode<(uint64)>(tmp%2#0) + let event%1#0: bytes = (concat method "ARC4TestStruct(uint64)" tmp%3#0) + (log event%1#0) + let tmp%4#0: Encoded(uint64) = bytes_encode(v#0) + let tmp%5#0: Encoded(uint64) = bytes_encode<(uint64)>(tmp%4#0) + let event%2#0: bytes = (concat method "ARC4TestStruct(uint64)" tmp%5#0) + (log event%2#0) + let tmp%6#0: Encoded(uint64) = bytes_encode(v#0) + let tmp%7#0: Encoded(uint64) = bytes_encode<(uint64)>(tmp%6#0) + let event%3#0: bytes = (concat method "ARC4TestStruct(uint64)" tmp%7#0) + (log event%3#0) + let tmp%8#0: Encoded(uint64) = bytes_encode(v#0) + let tmp%9#0: Encoded(uint64) = bytes_encode<(uint64)>(tmp%8#0) + let event%4#0: bytes = (concat method "ARC4TestStruct(uint64)" tmp%9#0) + (log event%4#0) + let tmp%10#0: Encoded(uint64) = bytes_encode(v#0) + let tmp%11#0: Encoded(uint64) = bytes_encode<(uint64)>(tmp%10#0) + let event%5#0: bytes = (concat method "ARC4TestStruct(uint64)" tmp%11#0) + (log event%5#0) + let tmp%12#0: Encoded(uint64) = bytes_encode(v#0) + let tmp%13#0: Encoded(uint64) = bytes_encode<(uint64)>(tmp%12#0) + let event%6#0: bytes = (concat method "ARC4TestStruct(uint64)" tmp%13#0) + (log event%6#0) + let tmp%14#0: Encoded(uint64) = bytes_encode(v#0) + let tmp%15#0: Encoded(uint64) = bytes_encode<(uint64)>(tmp%14#0) + let event%7#0: bytes = (concat method "ARC4TestStruct(uint64)" tmp%15#0) + (log event%7#0) + return + +subroutine test_cases.structure_methods.contract.TestContract.__puya_arc4_router__() -> bool: + block@0: // L69 + let tmp%0#0: uint64 = (txn NumAppArgs) + let tmp%1#0: bool = (!= tmp%0#0 0u) + goto tmp%1#0 ? block@1 : block@4 + block@1: // abi_routing_L69 + let tmp%2#0: bytes = (txna ApplicationArgs 0) + switch tmp%2#0 {method "test()void" => block@2, * => block@3} + block@2: // test_route_L70 + let tmp%3#0: uint64 = (txn OnCompletion) + let tmp%4#0: bool = (== tmp%3#0 NoOp) + let tmp%5#0: uint64 = (txn ApplicationID) + let tmp%6#0: bool = (!= tmp%5#0 0u) + let tmp%7#0: bool = (&& tmp%4#0 tmp%6#0) + (assert tmp%7#0) + test_cases.structure_methods.contract.TestContract.test[routing]() + goto block@3 + block@3: // switch_case_next_L69 + goto block@5 + block@4: // __algopy_default_create_L1 + let tmp%8#0: uint64 = (txn OnCompletion) + let tmp%9#0: bool = (== tmp%8#0 NoOp) + let tmp%10#0: uint64 = (txn ApplicationID) + let tmp%11#0: bool = (== tmp%10#0 0u) + let tmp%12#0: bool = (&& tmp%9#0 tmp%11#0) + (assert tmp%12#0) + test_cases.structure_methods.contract.TestContract.__algopy_default_create() + exit 1u + block@5: // after_if_else_L69 + exit 0u + +subroutine test_cases.structure_methods.contract.TestContract.test[routing]() -> void: + block@0: // L70 + test_cases.structure_methods.contract.TestContract.test() + exit 1u + +subroutine test_cases.structure_methods.contract.TestContract.test() -> void: + block@0: // L70 + let tmp%0#0: Encoded(uint64) = bytes_encode<(uint64)>(0x0000000000000009) + let (return_value_times%0#0: uint64, return_value_times%1#0: Encoded(uint64)) = test_cases.structure_methods.contract.ARC4TestStruct.return_value_times(tmp%0#0, 2u) + let tmp%1#0: bool = (== 18u return_value_times%0#0) + (assert tmp%1#0) + let tmp%2#0: Encoded(uint64) = bytes_encode<(uint64)>(9u) + let (return_value_times%2#0: uint64, return_value_times%3#0: Encoded(uint64)) = test_cases.structure_methods.contract.TestStruct.return_value_times(tmp%2#0, 2u) + let tmp%3#0: bool = (== 18u return_value_times%2#0) + (assert tmp%3#0) + let tmp%4#0: uint64 = test_cases.structure_methods.contract.TestNamedTuple.return_value_times(9u, 2u) + let tmp%5#0: bool = (== 18u tmp%4#0) + (assert tmp%5#0) + let tmp%6#0: Encoded(uint64) = bytes_encode<(uint64)>(0x0000000000000009) + let (return_value_times%4#0: uint64, return_value_times%5#0: Encoded(uint64)) = test_cases.structure_methods.contract.ARC4TestStruct.return_value_times(tmp%6#0, 2u) + let tmp%7#0: bool = (== 18u return_value_times%4#0) + (assert tmp%7#0) + let tmp%8#0: Encoded(uint64) = bytes_encode<(uint64)>(9u) + let (return_value_times%6#0: uint64, return_value_times%7#0: Encoded(uint64)) = test_cases.structure_methods.contract.TestStruct.return_value_times(tmp%8#0, 2u) + let tmp%9#0: bool = (== 18u return_value_times%6#0) + (assert tmp%9#0) + let tmp%10#0: uint64 = test_cases.structure_methods.contract.TestNamedTuple.return_value_times(9u, 2u) + let tmp%11#0: bool = (== 18u tmp%10#0) + (assert tmp%11#0) + let tmp%12#0: uint64 = test_cases.structure_methods.contract.ARC4TestStruct.return1() + let tmp%13#0: bool = (== 1u tmp%12#0) + (assert tmp%13#0) + let tmp%14#0: uint64 = test_cases.structure_methods.contract.TestStruct.return1() + let tmp%15#0: bool = (== 1u tmp%14#0) + (assert tmp%15#0) + let tmp%16#0: uint64 = test_cases.structure_methods.contract.TestNamedTuple.return1() + let tmp%17#0: bool = (== 1u tmp%16#0) + (assert tmp%17#0) + let tmp%18#0: uint64 = test_cases.structure_methods.contract.ARC4TestStruct.return1() + let tmp%19#0: bool = (== 1u tmp%18#0) + (assert tmp%19#0) + let tmp%20#0: uint64 = test_cases.structure_methods.contract.TestStruct.return1() + let tmp%21#0: bool = (== 1u tmp%20#0) + (assert tmp%21#0) + let tmp%22#0: uint64 = test_cases.structure_methods.contract.TestNamedTuple.return1() + let tmp%23#0: bool = (== 1u tmp%22#0) + (assert tmp%23#0) + let tmp%24#0: uint64 = test_cases.structure_methods.contract.GroupedMethods.never_inlined_usually_inlined(2u) + let tmp%25#0: bool = (== 3u tmp%24#0) + (assert tmp%25#0) + let tmp%26#0: uint64 = test_cases.structure_methods.contract.GroupedMethods.never_inlined_usually_inlined(2u) + let tmp%27#0: bool = (== 3u tmp%26#0) + (assert tmp%27#0) + let tmp%28#0: uint64 = test_cases.structure_methods.contract.GroupedMethods.usually_inlined(2u) + let tmp%29#0: bool = (== 3u tmp%28#0) + (assert tmp%29#0) + let tmp%30#0: uint64 = test_cases.structure_methods.contract.GroupedMethods.usually_inlined(2u) + let tmp%31#0: bool = (== 3u tmp%30#0) + (assert tmp%31#0) + test_cases.structure_methods.contract.GroupedMethods.always_inlined_not_usually_inlined(2u) + test_cases.structure_methods.contract.GroupedMethods.always_inlined_not_usually_inlined(2u) + test_cases.structure_methods.contract.GroupedMethods.not_usually_inlined(2u) + test_cases.structure_methods.contract.GroupedMethods.not_usually_inlined(2u) + return + +subroutine test_cases.structure_methods.contract.TestContract.__algopy_default_create() -> void: + block@0: // L1 + return \ No newline at end of file diff --git a/test_cases/structure_methods/out/TestContract.ir/TestContract.approval.001.ssa.opt.ir b/test_cases/structure_methods/out/TestContract.ir/TestContract.approval.001.ssa.opt.ir new file mode 100644 index 0000000000..f9b65f83ba --- /dev/null +++ b/test_cases/structure_methods/out/TestContract.ir/TestContract.approval.001.ssa.opt.ir @@ -0,0 +1,161 @@ +main algopy.arc4.ARC4Contract.approval_program: + block@0: // L1 + let tmp%0#1: uint64 = (txn NumAppArgs) + let tmp%1#0: bool = (!= tmp%0#1 0u) + goto tmp%0#1 ? block@2 : block@5 + block@2: // abi_routing_L69 + let tmp%2#0: bytes = (txna ApplicationArgs 0) + switch tmp%2#0 {method "test()void" => block@3, * => block@4} + block@3: // test_route_L70 + let tmp%3#0: uint64 = (txn OnCompletion) + let tmp%4#0: bool = (! tmp%3#0) + let tmp%5#0: uint64 = (txn ApplicationID) + let tmp%6#0: bool = (!= tmp%5#0 0u) + let tmp%7#0: bool = (&& tmp%4#0 tmp%5#0) + (assert tmp%7#0) + test_cases.structure_methods.contract.TestContract.test[routing]() + goto block@4 + block@4: // switch_case_next_L69 + fail + block@5: // __algopy_default_create_L1 + let tmp%8#0: uint64 = (txn OnCompletion) + let tmp%9#0: bool = (! tmp%8#0) + let tmp%10#0: uint64 = (txn ApplicationID) + let tmp%11#0: bool = (! tmp%10#0) + let tmp%12#0: bool = (&& tmp%9#0 tmp%11#0) + (assert tmp%12#0) + test_cases.structure_methods.contract.TestContract.__algopy_default_create() + exit 1u + +subroutine test_cases.structure_methods.contract.ARC4TestStruct.return_value_times(self: Encoded(uint64), times: uint64) -> : + block@0: // L9 + let tuple_item%0#0: Encoded(uint64) = extract_value(self#0, 0) + let tmp%0#0: uint64 = decode_bytes(tuple_item%0#0) + let tmp%1#0: uint64 = (* tmp%0#0 times#0) + return tmp%1#0 self#0 + +subroutine test_cases.structure_methods.contract.ARC4TestStruct.return1() -> uint64: + block@0: // L12 + return 1u + +subroutine test_cases.structure_methods.contract.TestStruct.return_value_times(self: Encoded(uint64), times: uint64) -> : + block@0: // L20 + let tuple_item%0#0: Encoded(uint64) = extract_value(self#0, 0) + let values%0#0: uint64 = decode_bytes(tuple_item%0#0) + let tmp%0#0: uint64 = (* values%0#0 times#0) + return tmp%0#0 self#0 + +subroutine test_cases.structure_methods.contract.TestStruct.return1() -> uint64: + block@0: // L23 + return 1u + +subroutine test_cases.structure_methods.contract.TestNamedTuple.return_value_times(self.value: uint64, times: uint64) -> uint64: + block@0: // L31 + let tmp%0#0: uint64 = (* self.value#0 times#0) + return tmp%0#0 + +subroutine test_cases.structure_methods.contract.TestNamedTuple.return1() -> uint64: + block@0: // L34 + return 1u + +subroutine test_cases.structure_methods.contract.GroupedMethods.never_inlined_usually_inlined(v: uint64) -> uint64: + block@0: // L40 + let tmp%0#0: uint64 = (+ v#0 1u) + return tmp%0#0 + +subroutine test_cases.structure_methods.contract.GroupedMethods.always_inlined_not_usually_inlined(v: uint64) -> void: + block@0: // L44 + let tmp%0#0: Encoded(uint64) = bytes_encode(v#0) + let tmp%1#0: Encoded(uint64) = bytes_encode<(uint64)>(tmp%0#0) + let event%0#0: bytes = (concat method "ARC4TestStruct(uint64)" tmp%1#0) + (log event%0#0) + (log event%0#0) + (log event%0#0) + (log event%0#0) + (log event%0#0) + (log event%0#0) + (log event%0#0) + (log event%0#0) + return + +subroutine test_cases.structure_methods.contract.GroupedMethods.usually_inlined(v: uint64) -> uint64: + block@0: // L55 + let tmp%0#0: uint64 = (+ v#0 1u) + return tmp%0#0 + +subroutine test_cases.structure_methods.contract.GroupedMethods.not_usually_inlined(v: uint64) -> void: + block@0: // L58 + let tmp%0#0: Encoded(uint64) = bytes_encode(v#0) + let tmp%1#0: Encoded(uint64) = bytes_encode<(uint64)>(tmp%0#0) + let event%0#0: bytes = (concat method "ARC4TestStruct(uint64)" tmp%1#0) + (log event%0#0) + (log event%0#0) + (log event%0#0) + (log event%0#0) + (log event%0#0) + (log event%0#0) + (log event%0#0) + (log event%0#0) + return + +subroutine test_cases.structure_methods.contract.TestContract.test[routing]() -> void: + block@0: // L70 + let tmp%0#0: Encoded(uint64) = bytes_encode<(uint64)>(0x0000000000000009) + let (return_value_times%0#0: uint64, return_value_times%1#0: Encoded(uint64)) = test_cases.structure_methods.contract.ARC4TestStruct.return_value_times(tmp%0#0, 2u) + let tmp%1#0: bool = (== 18u return_value_times%0#0) + (assert tmp%1#0) + let tmp%2#0: Encoded(uint64) = bytes_encode<(uint64)>(9u) + let (return_value_times%2#0: uint64, return_value_times%3#0: Encoded(uint64)) = test_cases.structure_methods.contract.TestStruct.return_value_times(tmp%2#0, 2u) + let tmp%3#0: bool = (== 18u return_value_times%2#0) + (assert tmp%3#0) + let tmp%4#0: uint64 = test_cases.structure_methods.contract.TestNamedTuple.return_value_times(9u, 2u) + let tmp%5#0: bool = (== 18u tmp%4#0) + (assert tmp%5#0) + let (return_value_times%4#0: uint64, return_value_times%5#0: Encoded(uint64)) = test_cases.structure_methods.contract.ARC4TestStruct.return_value_times(tmp%0#0, 2u) + let tmp%7#0: bool = (== 18u return_value_times%4#0) + (assert tmp%7#0) + let (return_value_times%6#0: uint64, return_value_times%7#0: Encoded(uint64)) = test_cases.structure_methods.contract.TestStruct.return_value_times(tmp%2#0, 2u) + let tmp%9#0: bool = (== 18u return_value_times%6#0) + (assert tmp%9#0) + let tmp%10#0: uint64 = test_cases.structure_methods.contract.TestNamedTuple.return_value_times(9u, 2u) + let tmp%11#0: bool = (== 18u tmp%10#0) + (assert tmp%11#0) + let tmp%12#0: uint64 = test_cases.structure_methods.contract.ARC4TestStruct.return1() + let tmp%13#0: bool = (== 1u tmp%12#0) + (assert tmp%13#0) + let tmp%14#0: uint64 = test_cases.structure_methods.contract.TestStruct.return1() + let tmp%15#0: bool = (== 1u tmp%14#0) + (assert tmp%15#0) + let tmp%16#0: uint64 = test_cases.structure_methods.contract.TestNamedTuple.return1() + let tmp%17#0: bool = (== 1u tmp%16#0) + (assert tmp%17#0) + let tmp%18#0: uint64 = test_cases.structure_methods.contract.ARC4TestStruct.return1() + let tmp%19#0: bool = (== 1u tmp%18#0) + (assert tmp%19#0) + let tmp%20#0: uint64 = test_cases.structure_methods.contract.TestStruct.return1() + let tmp%21#0: bool = (== 1u tmp%20#0) + (assert tmp%21#0) + let tmp%22#0: uint64 = test_cases.structure_methods.contract.TestNamedTuple.return1() + let tmp%23#0: bool = (== 1u tmp%22#0) + (assert tmp%23#0) + let tmp%24#0: uint64 = test_cases.structure_methods.contract.GroupedMethods.never_inlined_usually_inlined(2u) + let tmp%25#0: bool = (== 3u tmp%24#0) + (assert tmp%25#0) + let tmp%26#0: uint64 = test_cases.structure_methods.contract.GroupedMethods.never_inlined_usually_inlined(2u) + let tmp%27#0: bool = (== 3u tmp%26#0) + (assert tmp%27#0) + let tmp%28#0: uint64 = test_cases.structure_methods.contract.GroupedMethods.usually_inlined(2u) + let tmp%29#0: bool = (== 3u tmp%28#0) + (assert tmp%29#0) + let tmp%30#0: uint64 = test_cases.structure_methods.contract.GroupedMethods.usually_inlined(2u) + let tmp%31#0: bool = (== 3u tmp%30#0) + (assert tmp%31#0) + test_cases.structure_methods.contract.GroupedMethods.always_inlined_not_usually_inlined(2u) + test_cases.structure_methods.contract.GroupedMethods.always_inlined_not_usually_inlined(2u) + test_cases.structure_methods.contract.GroupedMethods.not_usually_inlined(2u) + test_cases.structure_methods.contract.GroupedMethods.not_usually_inlined(2u) + exit 1u + +subroutine test_cases.structure_methods.contract.TestContract.__algopy_default_create() -> void: + block@0: // L1 + return \ No newline at end of file diff --git a/test_cases/structure_methods/out/TestContract.ir/TestContract.approval.002.ssa.opt.ir b/test_cases/structure_methods/out/TestContract.ir/TestContract.approval.002.ssa.opt.ir new file mode 100644 index 0000000000..0d7966cdac --- /dev/null +++ b/test_cases/structure_methods/out/TestContract.ir/TestContract.approval.002.ssa.opt.ir @@ -0,0 +1,132 @@ +main algopy.arc4.ARC4Contract.approval_program: + block@0: // L1 + let tmp%0#1: uint64 = (txn NumAppArgs) + goto tmp%0#1 ? block@2 : block@5 + block@2: // abi_routing_L69 + let tmp%2#0: bytes = (txna ApplicationArgs 0) + switch tmp%2#0 {method "test()void" => block@3, * => block@4} + block@3: // test_route_L70 + let tmp%3#0: uint64 = (txn OnCompletion) + let tmp%4#0: bool = (! tmp%3#0) + let tmp%5#0: uint64 = (txn ApplicationID) + let tmp%7#0: bool = (&& tmp%4#0 tmp%5#0) + (assert tmp%7#0) + test_cases.structure_methods.contract.TestContract.test[routing]() + goto block@4 + block@4: // switch_case_next_L69 + fail + block@5: // __algopy_default_create_L1 + let tmp%8#0: uint64 = (txn OnCompletion) + let tmp%9#0: bool = (! tmp%8#0) + let tmp%10#0: uint64 = (txn ApplicationID) + let tmp%11#0: bool = (! tmp%10#0) + let tmp%12#0: bool = (&& tmp%9#0 tmp%11#0) + (assert tmp%12#0) + exit 1u + +subroutine test_cases.structure_methods.contract.ARC4TestStruct.return_value_times(self: Encoded(uint64), times: uint64) -> : + block@0: // L9 + let tuple_item%0#0: Encoded(uint64) = extract_value(self#0, 0) + let tmp%0#0: uint64 = decode_bytes(tuple_item%0#0) + let tmp%1#0: uint64 = (* tmp%0#0 times#0) + return tmp%1#0 self#0 + +subroutine test_cases.structure_methods.contract.TestStruct.return_value_times(self: Encoded(uint64), times: uint64) -> : + block@0: // L20 + let tuple_item%0#0: Encoded(uint64) = extract_value(self#0, 0) + let values%0#0: uint64 = decode_bytes(tuple_item%0#0) + let tmp%0#0: uint64 = (* values%0#0 times#0) + return tmp%0#0 self#0 + +subroutine test_cases.structure_methods.contract.TestNamedTuple.return_value_times(self.value: uint64, times: uint64) -> uint64: + block@0: // L31 + let tmp%0#0: uint64 = (* self.value#0 times#0) + return tmp%0#0 + +subroutine test_cases.structure_methods.contract.GroupedMethods.never_inlined_usually_inlined(v: uint64) -> uint64: + block@0: // L40 + let tmp%0#0: uint64 = (+ v#0 1u) + return tmp%0#0 + +subroutine test_cases.structure_methods.contract.GroupedMethods.usually_inlined(v: uint64) -> uint64: + block@0: // L55 + let tmp%0#0: uint64 = (+ v#0 1u) + return tmp%0#0 + +subroutine test_cases.structure_methods.contract.GroupedMethods.not_usually_inlined(v: uint64) -> void: + block@0: // L58 + let tmp%0#0: Encoded(uint64) = bytes_encode(v#0) + let tmp%1#0: Encoded(uint64) = bytes_encode<(uint64)>(tmp%0#0) + let event%0#0: bytes = (concat method "ARC4TestStruct(uint64)" tmp%1#0) + (log event%0#0) + (log event%0#0) + (log event%0#0) + (log event%0#0) + (log event%0#0) + (log event%0#0) + (log event%0#0) + (log event%0#0) + return + +subroutine test_cases.structure_methods.contract.TestContract.test[routing]() -> void: + block@0: // L70 + let tmp%0#0: Encoded(uint64) = bytes_encode<(uint64)>(0x0000000000000009) + let (return_value_times%0#0: uint64, return_value_times%1#0: Encoded(uint64)) = test_cases.structure_methods.contract.ARC4TestStruct.return_value_times(tmp%0#0, 2u) + let tmp%1#0: bool = (== 18u return_value_times%0#0) + (assert tmp%1#0) + let tmp%2#0: Encoded(uint64) = bytes_encode<(uint64)>(9u) + let (return_value_times%2#0: uint64, return_value_times%3#0: Encoded(uint64)) = test_cases.structure_methods.contract.TestStruct.return_value_times(tmp%2#0, 2u) + let tmp%3#0: bool = (== 18u return_value_times%2#0) + (assert tmp%3#0) + let tmp%4#0: uint64 = test_cases.structure_methods.contract.TestNamedTuple.return_value_times(9u, 2u) + let tmp%5#0: bool = (== 18u tmp%4#0) + (assert tmp%5#0) + let (return_value_times%4#0: uint64, return_value_times%5#0: Encoded(uint64)) = test_cases.structure_methods.contract.ARC4TestStruct.return_value_times(tmp%0#0, 2u) + let tmp%7#0: bool = (== 18u return_value_times%4#0) + (assert tmp%7#0) + let (return_value_times%6#0: uint64, return_value_times%7#0: Encoded(uint64)) = test_cases.structure_methods.contract.TestStruct.return_value_times(tmp%2#0, 2u) + let tmp%9#0: bool = (== 18u return_value_times%6#0) + (assert tmp%9#0) + let tmp%10#0: uint64 = test_cases.structure_methods.contract.TestNamedTuple.return_value_times(9u, 2u) + let tmp%11#0: bool = (== 18u tmp%10#0) + (assert tmp%11#0) + let tmp%13#0: bool = 1u + let tmp%15#0: bool = 1u + let tmp%17#0: bool = 1u + let tmp%19#0: bool = 1u + let tmp%21#0: bool = 1u + let tmp%23#0: bool = 1u + let tmp%24#0: uint64 = test_cases.structure_methods.contract.GroupedMethods.never_inlined_usually_inlined(2u) + let tmp%25#0: bool = (== 3u tmp%24#0) + (assert tmp%25#0) + let tmp%26#0: uint64 = test_cases.structure_methods.contract.GroupedMethods.never_inlined_usually_inlined(2u) + let tmp%27#0: bool = (== 3u tmp%26#0) + (assert tmp%27#0) + let tmp%28#0: uint64 = test_cases.structure_methods.contract.GroupedMethods.usually_inlined(2u) + let tmp%29#0: bool = (== 3u tmp%28#0) + (assert tmp%29#0) + let tmp%30#0: uint64 = test_cases.structure_methods.contract.GroupedMethods.usually_inlined(2u) + let tmp%31#0: bool = (== 3u tmp%30#0) + (assert tmp%31#0) + let tmp%0#1: Encoded(uint64) = bytes_encode(2u) + let tmp%1#1: Encoded(uint64) = bytes_encode<(uint64)>(tmp%0#1) + let event%0#0: bytes = (concat method "ARC4TestStruct(uint64)" tmp%1#1) + (log event%0#0) + (log event%0#0) + (log event%0#0) + (log event%0#0) + (log event%0#0) + (log event%0#0) + (log event%0#0) + (log event%0#0) + (log event%0#0) + (log event%0#0) + (log event%0#0) + (log event%0#0) + (log event%0#0) + (log event%0#0) + (log event%0#0) + (log event%0#0) + test_cases.structure_methods.contract.GroupedMethods.not_usually_inlined(2u) + test_cases.structure_methods.contract.GroupedMethods.not_usually_inlined(2u) + exit 1u \ No newline at end of file diff --git a/test_cases/structure_methods/out/TestContract.ir/TestContract.approval.003.ssa.opt.ir b/test_cases/structure_methods/out/TestContract.ir/TestContract.approval.003.ssa.opt.ir new file mode 100644 index 0000000000..01e71d7081 --- /dev/null +++ b/test_cases/structure_methods/out/TestContract.ir/TestContract.approval.003.ssa.opt.ir @@ -0,0 +1,112 @@ +main algopy.arc4.ARC4Contract.approval_program: + block@0: // L1 + let tmp%0#1: uint64 = (txn NumAppArgs) + goto tmp%0#1 ? block@2 : block@5 + block@2: // abi_routing_L69 + let tmp%2#0: bytes = (txna ApplicationArgs 0) + switch tmp%2#0 {method "test()void" => block@3, * => block@4} + block@3: // test_route_L70 + let tmp%3#0: uint64 = (txn OnCompletion) + let tmp%4#0: bool = (! tmp%3#0) + let tmp%5#0: uint64 = (txn ApplicationID) + let tmp%7#0: bool = (&& tmp%4#0 tmp%5#0) + (assert tmp%7#0) + test_cases.structure_methods.contract.TestContract.test[routing]() + goto block@4 + block@4: // switch_case_next_L69 + fail + block@5: // __algopy_default_create_L1 + let tmp%8#0: uint64 = (txn OnCompletion) + let tmp%9#0: bool = (! tmp%8#0) + let tmp%10#0: uint64 = (txn ApplicationID) + let tmp%11#0: bool = (! tmp%10#0) + let tmp%12#0: bool = (&& tmp%9#0 tmp%11#0) + (assert tmp%12#0) + exit 1u + +subroutine test_cases.structure_methods.contract.ARC4TestStruct.return_value_times(self: Encoded(uint64), times: uint64) -> : + block@0: // L9 + let tuple_item%0#0: Encoded(uint64) = extract_value(self#0, 0) + let tmp%0#0: uint64 = decode_bytes(tuple_item%0#0) + let tmp%1#0: uint64 = (* tmp%0#0 times#0) + return tmp%1#0 self#0 + +subroutine test_cases.structure_methods.contract.TestStruct.return_value_times(self: Encoded(uint64), times: uint64) -> : + block@0: // L20 + let tuple_item%0#0: Encoded(uint64) = extract_value(self#0, 0) + let values%0#0: uint64 = decode_bytes(tuple_item%0#0) + let tmp%0#0: uint64 = (* values%0#0 times#0) + return tmp%0#0 self#0 + +subroutine test_cases.structure_methods.contract.GroupedMethods.never_inlined_usually_inlined(v: uint64) -> uint64: + block@0: // L40 + let tmp%0#0: uint64 = (+ v#0 1u) + return tmp%0#0 + +subroutine test_cases.structure_methods.contract.GroupedMethods.not_usually_inlined(v: uint64) -> void: + block@0: // L58 + let tmp%0#0: Encoded(uint64) = bytes_encode(v#0) + let tmp%1#0: Encoded(uint64) = bytes_encode<(uint64)>(tmp%0#0) + let event%0#0: bytes = (concat method "ARC4TestStruct(uint64)" tmp%1#0) + (log event%0#0) + (log event%0#0) + (log event%0#0) + (log event%0#0) + (log event%0#0) + (log event%0#0) + (log event%0#0) + (log event%0#0) + return + +subroutine test_cases.structure_methods.contract.TestContract.test[routing]() -> void: + block@0: // L70 + let tmp%0#0: Encoded(uint64) = bytes_encode<(uint64)>(0x0000000000000009) + let (return_value_times%0#0: uint64, return_value_times%1#0: Encoded(uint64)) = test_cases.structure_methods.contract.ARC4TestStruct.return_value_times(tmp%0#0, 2u) + let tmp%1#0: bool = (== 18u return_value_times%0#0) + (assert tmp%1#0) + let tmp%2#0: Encoded(uint64) = bytes_encode<(uint64)>(9u) + let (return_value_times%2#0: uint64, return_value_times%3#0: Encoded(uint64)) = test_cases.structure_methods.contract.TestStruct.return_value_times(tmp%2#0, 2u) + let tmp%3#0: bool = (== 18u return_value_times%2#0) + (assert tmp%3#0) + let tmp%0#2: uint64 = 18u + let tmp%5#0: bool = 1u + let (return_value_times%4#0: uint64, return_value_times%5#0: Encoded(uint64)) = test_cases.structure_methods.contract.ARC4TestStruct.return_value_times(tmp%0#0, 2u) + let tmp%7#0: bool = (== 18u return_value_times%4#0) + (assert tmp%7#0) + let (return_value_times%6#0: uint64, return_value_times%7#0: Encoded(uint64)) = test_cases.structure_methods.contract.TestStruct.return_value_times(tmp%2#0, 2u) + let tmp%9#0: bool = (== 18u return_value_times%6#0) + (assert tmp%9#0) + let tmp%0#3: uint64 = 18u + let tmp%11#0: bool = 1u + let tmp%24#0: uint64 = test_cases.structure_methods.contract.GroupedMethods.never_inlined_usually_inlined(2u) + let tmp%25#0: bool = (== 3u tmp%24#0) + (assert tmp%25#0) + let tmp%26#0: uint64 = test_cases.structure_methods.contract.GroupedMethods.never_inlined_usually_inlined(2u) + let tmp%27#0: bool = (== 3u tmp%26#0) + (assert tmp%27#0) + let tmp%0#4: uint64 = 3u + let tmp%29#0: bool = 1u + let tmp%0#5: uint64 = 3u + let tmp%31#0: bool = 1u + let tmp%0#1: Encoded(uint64) = bytes_encode(2u) + let tmp%1#1: Encoded(uint64) = bytes_encode<(uint64)>(tmp%0#1) + let event%0#0: bytes = (concat method "ARC4TestStruct(uint64)" tmp%1#1) + (log event%0#0) + (log event%0#0) + (log event%0#0) + (log event%0#0) + (log event%0#0) + (log event%0#0) + (log event%0#0) + (log event%0#0) + (log event%0#0) + (log event%0#0) + (log event%0#0) + (log event%0#0) + (log event%0#0) + (log event%0#0) + (log event%0#0) + (log event%0#0) + test_cases.structure_methods.contract.GroupedMethods.not_usually_inlined(2u) + test_cases.structure_methods.contract.GroupedMethods.not_usually_inlined(2u) + exit 1u \ No newline at end of file diff --git a/test_cases/structure_methods/out/TestContract.ir/TestContract.approval.004.ssa.opt.ir b/test_cases/structure_methods/out/TestContract.ir/TestContract.approval.004.ssa.opt.ir new file mode 100644 index 0000000000..826c9282d6 --- /dev/null +++ b/test_cases/structure_methods/out/TestContract.ir/TestContract.approval.004.ssa.opt.ir @@ -0,0 +1,104 @@ +main algopy.arc4.ARC4Contract.approval_program: + block@0: // L1 + let tmp%0#1: uint64 = (txn NumAppArgs) + goto tmp%0#1 ? block@2 : block@5 + block@2: // abi_routing_L69 + let tmp%2#0: bytes = (txna ApplicationArgs 0) + switch tmp%2#0 {method "test()void" => block@3, * => block@4} + block@3: // test_route_L70 + let tmp%3#0: uint64 = (txn OnCompletion) + let tmp%4#0: bool = (! tmp%3#0) + let tmp%5#0: uint64 = (txn ApplicationID) + let tmp%7#0: bool = (&& tmp%4#0 tmp%5#0) + (assert tmp%7#0) + test_cases.structure_methods.contract.TestContract.test[routing]() + goto block@4 + block@4: // switch_case_next_L69 + fail + block@5: // __algopy_default_create_L1 + let tmp%8#0: uint64 = (txn OnCompletion) + let tmp%9#0: bool = (! tmp%8#0) + let tmp%10#0: uint64 = (txn ApplicationID) + let tmp%11#0: bool = (! tmp%10#0) + let tmp%12#0: bool = (&& tmp%9#0 tmp%11#0) + (assert tmp%12#0) + exit 1u + +subroutine test_cases.structure_methods.contract.ARC4TestStruct.return_value_times(self: Encoded(uint64), times: uint64) -> : + block@0: // L9 + let tuple_item%0#0: Encoded(uint64) = extract_value(self#0, 0) + let tmp%0#0: uint64 = decode_bytes(tuple_item%0#0) + let tmp%1#0: uint64 = (* tmp%0#0 times#0) + return tmp%1#0 self#0 + +subroutine test_cases.structure_methods.contract.TestStruct.return_value_times(self: Encoded(uint64), times: uint64) -> : + block@0: // L20 + let tuple_item%0#0: Encoded(uint64) = extract_value(self#0, 0) + let values%0#0: uint64 = decode_bytes(tuple_item%0#0) + let tmp%0#0: uint64 = (* values%0#0 times#0) + return tmp%0#0 self#0 + +subroutine test_cases.structure_methods.contract.GroupedMethods.never_inlined_usually_inlined(v: uint64) -> uint64: + block@0: // L40 + let tmp%0#0: uint64 = (+ v#0 1u) + return tmp%0#0 + +subroutine test_cases.structure_methods.contract.GroupedMethods.not_usually_inlined(v: uint64) -> void: + block@0: // L58 + let tmp%0#0: Encoded(uint64) = bytes_encode(v#0) + let tmp%1#0: Encoded(uint64) = bytes_encode<(uint64)>(tmp%0#0) + let event%0#0: bytes = (concat method "ARC4TestStruct(uint64)" tmp%1#0) + (log event%0#0) + (log event%0#0) + (log event%0#0) + (log event%0#0) + (log event%0#0) + (log event%0#0) + (log event%0#0) + (log event%0#0) + return + +subroutine test_cases.structure_methods.contract.TestContract.test[routing]() -> void: + block@0: // L70 + let tmp%0#0: Encoded(uint64) = bytes_encode<(uint64)>(0x0000000000000009) + let (return_value_times%0#0: uint64, return_value_times%1#0: Encoded(uint64)) = test_cases.structure_methods.contract.ARC4TestStruct.return_value_times(tmp%0#0, 2u) + let tmp%1#0: bool = (== 18u return_value_times%0#0) + (assert tmp%1#0) + let tmp%2#0: Encoded(uint64) = bytes_encode<(uint64)>(9u) + let (return_value_times%2#0: uint64, return_value_times%3#0: Encoded(uint64)) = test_cases.structure_methods.contract.TestStruct.return_value_times(tmp%2#0, 2u) + let tmp%3#0: bool = (== 18u return_value_times%2#0) + (assert tmp%3#0) + let (return_value_times%4#0: uint64, return_value_times%5#0: Encoded(uint64)) = test_cases.structure_methods.contract.ARC4TestStruct.return_value_times(tmp%0#0, 2u) + let tmp%7#0: bool = (== 18u return_value_times%4#0) + (assert tmp%7#0) + let (return_value_times%6#0: uint64, return_value_times%7#0: Encoded(uint64)) = test_cases.structure_methods.contract.TestStruct.return_value_times(tmp%2#0, 2u) + let tmp%9#0: bool = (== 18u return_value_times%6#0) + (assert tmp%9#0) + let tmp%24#0: uint64 = test_cases.structure_methods.contract.GroupedMethods.never_inlined_usually_inlined(2u) + let tmp%25#0: bool = (== 3u tmp%24#0) + (assert tmp%25#0) + let tmp%26#0: uint64 = test_cases.structure_methods.contract.GroupedMethods.never_inlined_usually_inlined(2u) + let tmp%27#0: bool = (== 3u tmp%26#0) + (assert tmp%27#0) + let tmp%0#1: Encoded(uint64) = bytes_encode(2u) + let tmp%1#1: Encoded(uint64) = bytes_encode<(uint64)>(tmp%0#1) + let event%0#0: bytes = (concat method "ARC4TestStruct(uint64)" tmp%1#1) + (log event%0#0) + (log event%0#0) + (log event%0#0) + (log event%0#0) + (log event%0#0) + (log event%0#0) + (log event%0#0) + (log event%0#0) + (log event%0#0) + (log event%0#0) + (log event%0#0) + (log event%0#0) + (log event%0#0) + (log event%0#0) + (log event%0#0) + (log event%0#0) + test_cases.structure_methods.contract.GroupedMethods.not_usually_inlined(2u) + test_cases.structure_methods.contract.GroupedMethods.not_usually_inlined(2u) + exit 1u \ No newline at end of file diff --git a/test_cases/structure_methods/out/TestContract.ir/TestContract.approval.100.ssa.array.ir b/test_cases/structure_methods/out/TestContract.ir/TestContract.approval.100.ssa.array.ir new file mode 100644 index 0000000000..9e5f7ac507 --- /dev/null +++ b/test_cases/structure_methods/out/TestContract.ir/TestContract.approval.100.ssa.array.ir @@ -0,0 +1,120 @@ +main algopy.arc4.ARC4Contract.approval_program: + block@0: // L1 + let tmp%0#1: uint64 = (txn NumAppArgs) + goto tmp%0#1 ? block@2 : block@5 + block@2: // abi_routing_L69 + let tmp%2#0: bytes = (txna ApplicationArgs 0) + switch tmp%2#0 {method "test()void" => block@3, * => block@4} + block@3: // test_route_L70 + let tmp%3#0: uint64 = (txn OnCompletion) + let tmp%4#0: bool = (! tmp%3#0) + let tmp%5#0: uint64 = (txn ApplicationID) + let tmp%7#0: bool = (&& tmp%4#0 tmp%5#0) + (assert tmp%7#0) + test_cases.structure_methods.contract.TestContract.test[routing]() + goto block@4 + block@4: // switch_case_next_L69 + fail + block@5: // __algopy_default_create_L1 + let tmp%8#0: uint64 = (txn OnCompletion) + let tmp%9#0: bool = (! tmp%8#0) + let tmp%10#0: uint64 = (txn ApplicationID) + let tmp%11#0: bool = (! tmp%10#0) + let tmp%12#0: bool = (&& tmp%9#0 tmp%11#0) + (assert tmp%12#0) + exit 1u + +subroutine test_cases.structure_methods.contract.ARC4TestStruct.return_value_times(self: Encoded(uint64), times: uint64) -> : + block@0: // L9 + let aggregate%extract%0#0: bytes = (extract3 self#0 0u 8u) + let tuple_item%0#0: Encoded(uint64) = aggregate%extract%0#0 + let tmp%0#0: uint64 = (btoi tuple_item%0#0) + let tmp%1#0: uint64 = (* tmp%0#0 times#0) + return tmp%1#0 self#0 + +subroutine test_cases.structure_methods.contract.TestStruct.return_value_times(self: Encoded(uint64), times: uint64) -> : + block@0: // L20 + let aggregate%extract%0#0: bytes = (extract3 self#0 0u 8u) + let tuple_item%0#0: Encoded(uint64) = aggregate%extract%0#0 + let values%0#0: uint64 = (btoi tuple_item%0#0) + let tmp%0#0: uint64 = (* values%0#0 times#0) + return tmp%0#0 self#0 + +subroutine test_cases.structure_methods.contract.GroupedMethods.never_inlined_usually_inlined(v: uint64) -> uint64: + block@0: // L40 + let tmp%0#0: uint64 = (+ v#0 1u) + return tmp%0#0 + +subroutine test_cases.structure_methods.contract.GroupedMethods.not_usually_inlined(v: uint64) -> void: + block@0: // L58 + let aggregate%val_as_bytes%0#0: bytes[8] = (itob v#0) + let aggregate%as_Encoded(uint64)%0#0: Encoded(uint64) = aggregate%val_as_bytes%0#0 + let tmp%0#0: Encoded(uint64) = aggregate%as_Encoded(uint64)%0#0 + let aggregate%head%0#0: bytes = (concat 0x tmp%0#0) + let aggregate%as_Encoded(uint64)%1#0: Encoded(uint64) = aggregate%head%0#0 + let tmp%1#0: Encoded(uint64) = aggregate%as_Encoded(uint64)%1#0 + let event%0#0: bytes = (concat method "ARC4TestStruct(uint64)" tmp%1#0) + (log event%0#0) + (log event%0#0) + (log event%0#0) + (log event%0#0) + (log event%0#0) + (log event%0#0) + (log event%0#0) + (log event%0#0) + return + +subroutine test_cases.structure_methods.contract.TestContract.test[routing]() -> void: + block@0: // L70 + let aggregate%head%0#0: bytes = (concat 0x 0x0000000000000009) + let aggregate%as_Encoded(uint64)%0#0: Encoded(uint64) = aggregate%head%0#0 + let tmp%0#0: Encoded(uint64) = aggregate%as_Encoded(uint64)%0#0 + let (return_value_times%0#0: uint64, return_value_times%1#0: Encoded(uint64)) = test_cases.structure_methods.contract.ARC4TestStruct.return_value_times(tmp%0#0, 2u) + let tmp%1#0: bool = (== 18u return_value_times%0#0) + (assert tmp%1#0) + let aggregate%val_as_bytes%0#0: bytes[8] = (itob 9u) + let aggregate%as_Encoded(uint64)%1#0: Encoded(uint64) = aggregate%val_as_bytes%0#0 + let aggregate%head%1#0: bytes = (concat 0x aggregate%as_Encoded(uint64)%1#0) + let aggregate%as_Encoded(uint64)%2#0: Encoded(uint64) = aggregate%head%1#0 + let tmp%2#0: Encoded(uint64) = aggregate%as_Encoded(uint64)%2#0 + let (return_value_times%2#0: uint64, return_value_times%3#0: Encoded(uint64)) = test_cases.structure_methods.contract.TestStruct.return_value_times(tmp%2#0, 2u) + let tmp%3#0: bool = (== 18u return_value_times%2#0) + (assert tmp%3#0) + let (return_value_times%4#0: uint64, return_value_times%5#0: Encoded(uint64)) = test_cases.structure_methods.contract.ARC4TestStruct.return_value_times(tmp%0#0, 2u) + let tmp%7#0: bool = (== 18u return_value_times%4#0) + (assert tmp%7#0) + let (return_value_times%6#0: uint64, return_value_times%7#0: Encoded(uint64)) = test_cases.structure_methods.contract.TestStruct.return_value_times(tmp%2#0, 2u) + let tmp%9#0: bool = (== 18u return_value_times%6#0) + (assert tmp%9#0) + let tmp%24#0: uint64 = test_cases.structure_methods.contract.GroupedMethods.never_inlined_usually_inlined(2u) + let tmp%25#0: bool = (== 3u tmp%24#0) + (assert tmp%25#0) + let tmp%26#0: uint64 = test_cases.structure_methods.contract.GroupedMethods.never_inlined_usually_inlined(2u) + let tmp%27#0: bool = (== 3u tmp%26#0) + (assert tmp%27#0) + let aggregate%val_as_bytes%1#0: bytes[8] = (itob 2u) + let aggregate%as_Encoded(uint64)%3#0: Encoded(uint64) = aggregate%val_as_bytes%1#0 + let tmp%0#1: Encoded(uint64) = aggregate%as_Encoded(uint64)%3#0 + let aggregate%head%2#0: bytes = (concat 0x tmp%0#1) + let aggregate%as_Encoded(uint64)%4#0: Encoded(uint64) = aggregate%head%2#0 + let tmp%1#1: Encoded(uint64) = aggregate%as_Encoded(uint64)%4#0 + let event%0#0: bytes = (concat method "ARC4TestStruct(uint64)" tmp%1#1) + (log event%0#0) + (log event%0#0) + (log event%0#0) + (log event%0#0) + (log event%0#0) + (log event%0#0) + (log event%0#0) + (log event%0#0) + (log event%0#0) + (log event%0#0) + (log event%0#0) + (log event%0#0) + (log event%0#0) + (log event%0#0) + (log event%0#0) + (log event%0#0) + test_cases.structure_methods.contract.GroupedMethods.not_usually_inlined(2u) + test_cases.structure_methods.contract.GroupedMethods.not_usually_inlined(2u) + exit 1u \ No newline at end of file diff --git a/test_cases/structure_methods/out/TestContract.ir/TestContract.approval.200.ssa.array.opt.ir b/test_cases/structure_methods/out/TestContract.ir/TestContract.approval.200.ssa.array.opt.ir new file mode 100644 index 0000000000..49099ad6e0 --- /dev/null +++ b/test_cases/structure_methods/out/TestContract.ir/TestContract.approval.200.ssa.array.opt.ir @@ -0,0 +1,91 @@ +main algopy.arc4.ARC4Contract.approval_program: + block@0: // L1 + let tmp%0#1: uint64 = (txn NumAppArgs) + goto tmp%0#1 ? block@2 : block@5 + block@2: // abi_routing_L69 + let tmp%2#0: bytes = (txna ApplicationArgs 0) + switch tmp%2#0 {method "test()void" => block@3, * => block@4} + block@3: // test_route_L70 + let tmp%3#0: uint64 = (txn OnCompletion) + let tmp%4#0: bool = (! tmp%3#0) + let tmp%5#0: uint64 = (txn ApplicationID) + let tmp%7#0: bool = (&& tmp%4#0 tmp%5#0) + (assert tmp%7#0) + test_cases.structure_methods.contract.TestContract.test[routing]() + goto block@4 + block@4: // switch_case_next_L69 + fail + block@5: // __algopy_default_create_L1 + let tmp%8#0: uint64 = (txn OnCompletion) + let tmp%9#0: bool = (! tmp%8#0) + let tmp%10#0: uint64 = (txn ApplicationID) + let tmp%11#0: bool = (! tmp%10#0) + let tmp%12#0: bool = (&& tmp%9#0 tmp%11#0) + (assert tmp%12#0) + exit 1u + +subroutine test_cases.structure_methods.contract.GroupedMethods.never_inlined_usually_inlined(v: uint64) -> uint64: + block@0: // L40 + let tmp%0#0: uint64 = (+ v#0 1u) + return tmp%0#0 + +subroutine test_cases.structure_methods.contract.GroupedMethods.not_usually_inlined(v: uint64) -> void: + block@0: // L58 + let aggregate%val_as_bytes%0#0: bytes[8] = (itob v#0) + let aggregate%head%0#0: bytes = aggregate%val_as_bytes%0#0 + let event%0#0: bytes = (concat method "ARC4TestStruct(uint64)" aggregate%val_as_bytes%0#0) + (log event%0#0) + (log event%0#0) + (log event%0#0) + (log event%0#0) + (log event%0#0) + (log event%0#0) + (log event%0#0) + (log event%0#0) + return + +subroutine test_cases.structure_methods.contract.TestContract.test[routing]() -> void: + block@0: // L70 + let self#0: Encoded(uint64) = 0x0000000000000009 + let tmp%0#2: uint64 = 9u + let tmp%1#2: uint64 = 18u + let tmp%1#0: bool = 1u + let aggregate%val_as_bytes%0#0: bytes[8] = (itob 9u) + let self#1: Encoded(uint64) = aggregate%val_as_bytes%0#0 + let values%0#0: uint64 = 9u + let tmp%0#3: uint64 = 18u + let tmp%3#0: bool = 1u + let tmp%0#4: uint64 = 9u + let tmp%1#3: uint64 = 18u + let tmp%7#0: bool = 1u + let values%0#1: uint64 = 9u + let tmp%0#5: uint64 = 18u + let tmp%9#0: bool = 1u + let tmp%24#0: uint64 = test_cases.structure_methods.contract.GroupedMethods.never_inlined_usually_inlined(2u) + let tmp%25#0: bool = (== 3u tmp%24#0) + (assert tmp%25#0) + let tmp%26#0: uint64 = test_cases.structure_methods.contract.GroupedMethods.never_inlined_usually_inlined(2u) + let tmp%27#0: bool = (== 3u tmp%26#0) + (assert tmp%27#0) + let aggregate%val_as_bytes%1#0: bytes[8] = (itob 2u) + let aggregate%head%2#0: bytes = aggregate%val_as_bytes%1#0 + let event%0#0: bytes = 0xed3267e80000000000000002 + (log 0xed3267e80000000000000002) + (log 0xed3267e80000000000000002) + (log 0xed3267e80000000000000002) + (log 0xed3267e80000000000000002) + (log 0xed3267e80000000000000002) + (log 0xed3267e80000000000000002) + (log 0xed3267e80000000000000002) + (log 0xed3267e80000000000000002) + (log 0xed3267e80000000000000002) + (log 0xed3267e80000000000000002) + (log 0xed3267e80000000000000002) + (log 0xed3267e80000000000000002) + (log 0xed3267e80000000000000002) + (log 0xed3267e80000000000000002) + (log 0xed3267e80000000000000002) + (log 0xed3267e80000000000000002) + test_cases.structure_methods.contract.GroupedMethods.not_usually_inlined(2u) + test_cases.structure_methods.contract.GroupedMethods.not_usually_inlined(2u) + exit 1u \ No newline at end of file diff --git a/test_cases/structure_methods/out/TestContract.ir/TestContract.approval.201.ssa.array.opt.ir b/test_cases/structure_methods/out/TestContract.ir/TestContract.approval.201.ssa.array.opt.ir new file mode 100644 index 0000000000..c75e10fb08 --- /dev/null +++ b/test_cases/structure_methods/out/TestContract.ir/TestContract.approval.201.ssa.array.opt.ir @@ -0,0 +1,72 @@ +main algopy.arc4.ARC4Contract.approval_program: + block@0: // L1 + let tmp%0#1: uint64 = (txn NumAppArgs) + goto tmp%0#1 ? block@2 : block@5 + block@2: // abi_routing_L69 + let tmp%2#0: bytes = (txna ApplicationArgs 0) + switch tmp%2#0 {method "test()void" => block@3, * => block@4} + block@3: // test_route_L70 + let tmp%3#0: uint64 = (txn OnCompletion) + let tmp%4#0: bool = (! tmp%3#0) + let tmp%5#0: uint64 = (txn ApplicationID) + let tmp%7#0: bool = (&& tmp%4#0 tmp%5#0) + (assert tmp%7#0) + test_cases.structure_methods.contract.TestContract.test[routing]() + goto block@4 + block@4: // switch_case_next_L69 + fail + block@5: // __algopy_default_create_L1 + let tmp%8#0: uint64 = (txn OnCompletion) + let tmp%9#0: bool = (! tmp%8#0) + let tmp%10#0: uint64 = (txn ApplicationID) + let tmp%11#0: bool = (! tmp%10#0) + let tmp%12#0: bool = (&& tmp%9#0 tmp%11#0) + (assert tmp%12#0) + exit 1u + +subroutine test_cases.structure_methods.contract.GroupedMethods.never_inlined_usually_inlined(v: uint64) -> uint64: + block@0: // L40 + let tmp%0#0: uint64 = (+ v#0 1u) + return tmp%0#0 + +subroutine test_cases.structure_methods.contract.GroupedMethods.not_usually_inlined(v: uint64) -> void: + block@0: // L58 + let aggregate%val_as_bytes%0#0: bytes[8] = (itob v#0) + let event%0#0: bytes = (concat method "ARC4TestStruct(uint64)" aggregate%val_as_bytes%0#0) + (log event%0#0) + (log event%0#0) + (log event%0#0) + (log event%0#0) + (log event%0#0) + (log event%0#0) + (log event%0#0) + (log event%0#0) + return + +subroutine test_cases.structure_methods.contract.TestContract.test[routing]() -> void: + block@0: // L70 + let tmp%24#0: uint64 = test_cases.structure_methods.contract.GroupedMethods.never_inlined_usually_inlined(2u) + let tmp%25#0: bool = (== 3u tmp%24#0) + (assert tmp%25#0) + let tmp%26#0: uint64 = test_cases.structure_methods.contract.GroupedMethods.never_inlined_usually_inlined(2u) + let tmp%27#0: bool = (== 3u tmp%26#0) + (assert tmp%27#0) + (log 0xed3267e80000000000000002) + (log 0xed3267e80000000000000002) + (log 0xed3267e80000000000000002) + (log 0xed3267e80000000000000002) + (log 0xed3267e80000000000000002) + (log 0xed3267e80000000000000002) + (log 0xed3267e80000000000000002) + (log 0xed3267e80000000000000002) + (log 0xed3267e80000000000000002) + (log 0xed3267e80000000000000002) + (log 0xed3267e80000000000000002) + (log 0xed3267e80000000000000002) + (log 0xed3267e80000000000000002) + (log 0xed3267e80000000000000002) + (log 0xed3267e80000000000000002) + (log 0xed3267e80000000000000002) + test_cases.structure_methods.contract.GroupedMethods.not_usually_inlined(2u) + test_cases.structure_methods.contract.GroupedMethods.not_usually_inlined(2u) + exit 1u \ No newline at end of file diff --git a/test_cases/structure_methods/out/TestContract.ir/TestContract.approval.300.ssa.slot.ir b/test_cases/structure_methods/out/TestContract.ir/TestContract.approval.300.ssa.slot.ir new file mode 100644 index 0000000000..c75e10fb08 --- /dev/null +++ b/test_cases/structure_methods/out/TestContract.ir/TestContract.approval.300.ssa.slot.ir @@ -0,0 +1,72 @@ +main algopy.arc4.ARC4Contract.approval_program: + block@0: // L1 + let tmp%0#1: uint64 = (txn NumAppArgs) + goto tmp%0#1 ? block@2 : block@5 + block@2: // abi_routing_L69 + let tmp%2#0: bytes = (txna ApplicationArgs 0) + switch tmp%2#0 {method "test()void" => block@3, * => block@4} + block@3: // test_route_L70 + let tmp%3#0: uint64 = (txn OnCompletion) + let tmp%4#0: bool = (! tmp%3#0) + let tmp%5#0: uint64 = (txn ApplicationID) + let tmp%7#0: bool = (&& tmp%4#0 tmp%5#0) + (assert tmp%7#0) + test_cases.structure_methods.contract.TestContract.test[routing]() + goto block@4 + block@4: // switch_case_next_L69 + fail + block@5: // __algopy_default_create_L1 + let tmp%8#0: uint64 = (txn OnCompletion) + let tmp%9#0: bool = (! tmp%8#0) + let tmp%10#0: uint64 = (txn ApplicationID) + let tmp%11#0: bool = (! tmp%10#0) + let tmp%12#0: bool = (&& tmp%9#0 tmp%11#0) + (assert tmp%12#0) + exit 1u + +subroutine test_cases.structure_methods.contract.GroupedMethods.never_inlined_usually_inlined(v: uint64) -> uint64: + block@0: // L40 + let tmp%0#0: uint64 = (+ v#0 1u) + return tmp%0#0 + +subroutine test_cases.structure_methods.contract.GroupedMethods.not_usually_inlined(v: uint64) -> void: + block@0: // L58 + let aggregate%val_as_bytes%0#0: bytes[8] = (itob v#0) + let event%0#0: bytes = (concat method "ARC4TestStruct(uint64)" aggregate%val_as_bytes%0#0) + (log event%0#0) + (log event%0#0) + (log event%0#0) + (log event%0#0) + (log event%0#0) + (log event%0#0) + (log event%0#0) + (log event%0#0) + return + +subroutine test_cases.structure_methods.contract.TestContract.test[routing]() -> void: + block@0: // L70 + let tmp%24#0: uint64 = test_cases.structure_methods.contract.GroupedMethods.never_inlined_usually_inlined(2u) + let tmp%25#0: bool = (== 3u tmp%24#0) + (assert tmp%25#0) + let tmp%26#0: uint64 = test_cases.structure_methods.contract.GroupedMethods.never_inlined_usually_inlined(2u) + let tmp%27#0: bool = (== 3u tmp%26#0) + (assert tmp%27#0) + (log 0xed3267e80000000000000002) + (log 0xed3267e80000000000000002) + (log 0xed3267e80000000000000002) + (log 0xed3267e80000000000000002) + (log 0xed3267e80000000000000002) + (log 0xed3267e80000000000000002) + (log 0xed3267e80000000000000002) + (log 0xed3267e80000000000000002) + (log 0xed3267e80000000000000002) + (log 0xed3267e80000000000000002) + (log 0xed3267e80000000000000002) + (log 0xed3267e80000000000000002) + (log 0xed3267e80000000000000002) + (log 0xed3267e80000000000000002) + (log 0xed3267e80000000000000002) + (log 0xed3267e80000000000000002) + test_cases.structure_methods.contract.GroupedMethods.not_usually_inlined(2u) + test_cases.structure_methods.contract.GroupedMethods.not_usually_inlined(2u) + exit 1u \ No newline at end of file diff --git a/test_cases/structure_methods/out/TestContract.ir/TestContract.approval.400.destructured.ir b/test_cases/structure_methods/out/TestContract.ir/TestContract.approval.400.destructured.ir new file mode 100644 index 0000000000..c75e10fb08 --- /dev/null +++ b/test_cases/structure_methods/out/TestContract.ir/TestContract.approval.400.destructured.ir @@ -0,0 +1,72 @@ +main algopy.arc4.ARC4Contract.approval_program: + block@0: // L1 + let tmp%0#1: uint64 = (txn NumAppArgs) + goto tmp%0#1 ? block@2 : block@5 + block@2: // abi_routing_L69 + let tmp%2#0: bytes = (txna ApplicationArgs 0) + switch tmp%2#0 {method "test()void" => block@3, * => block@4} + block@3: // test_route_L70 + let tmp%3#0: uint64 = (txn OnCompletion) + let tmp%4#0: bool = (! tmp%3#0) + let tmp%5#0: uint64 = (txn ApplicationID) + let tmp%7#0: bool = (&& tmp%4#0 tmp%5#0) + (assert tmp%7#0) + test_cases.structure_methods.contract.TestContract.test[routing]() + goto block@4 + block@4: // switch_case_next_L69 + fail + block@5: // __algopy_default_create_L1 + let tmp%8#0: uint64 = (txn OnCompletion) + let tmp%9#0: bool = (! tmp%8#0) + let tmp%10#0: uint64 = (txn ApplicationID) + let tmp%11#0: bool = (! tmp%10#0) + let tmp%12#0: bool = (&& tmp%9#0 tmp%11#0) + (assert tmp%12#0) + exit 1u + +subroutine test_cases.structure_methods.contract.GroupedMethods.never_inlined_usually_inlined(v: uint64) -> uint64: + block@0: // L40 + let tmp%0#0: uint64 = (+ v#0 1u) + return tmp%0#0 + +subroutine test_cases.structure_methods.contract.GroupedMethods.not_usually_inlined(v: uint64) -> void: + block@0: // L58 + let aggregate%val_as_bytes%0#0: bytes[8] = (itob v#0) + let event%0#0: bytes = (concat method "ARC4TestStruct(uint64)" aggregate%val_as_bytes%0#0) + (log event%0#0) + (log event%0#0) + (log event%0#0) + (log event%0#0) + (log event%0#0) + (log event%0#0) + (log event%0#0) + (log event%0#0) + return + +subroutine test_cases.structure_methods.contract.TestContract.test[routing]() -> void: + block@0: // L70 + let tmp%24#0: uint64 = test_cases.structure_methods.contract.GroupedMethods.never_inlined_usually_inlined(2u) + let tmp%25#0: bool = (== 3u tmp%24#0) + (assert tmp%25#0) + let tmp%26#0: uint64 = test_cases.structure_methods.contract.GroupedMethods.never_inlined_usually_inlined(2u) + let tmp%27#0: bool = (== 3u tmp%26#0) + (assert tmp%27#0) + (log 0xed3267e80000000000000002) + (log 0xed3267e80000000000000002) + (log 0xed3267e80000000000000002) + (log 0xed3267e80000000000000002) + (log 0xed3267e80000000000000002) + (log 0xed3267e80000000000000002) + (log 0xed3267e80000000000000002) + (log 0xed3267e80000000000000002) + (log 0xed3267e80000000000000002) + (log 0xed3267e80000000000000002) + (log 0xed3267e80000000000000002) + (log 0xed3267e80000000000000002) + (log 0xed3267e80000000000000002) + (log 0xed3267e80000000000000002) + (log 0xed3267e80000000000000002) + (log 0xed3267e80000000000000002) + test_cases.structure_methods.contract.GroupedMethods.not_usually_inlined(2u) + test_cases.structure_methods.contract.GroupedMethods.not_usually_inlined(2u) + exit 1u \ No newline at end of file diff --git a/test_cases/structure_methods/out/TestContract.ir/TestContract.approval.500.build.mir b/test_cases/structure_methods/out/TestContract.ir/TestContract.approval.500.build.mir new file mode 100644 index 0000000000..ae368298b0 --- /dev/null +++ b/test_cases/structure_methods/out/TestContract.ir/TestContract.approval.500.build.mir @@ -0,0 +1,250 @@ +// Op Stack (out) +// algopy.arc4.ARC4Contract.approval_program() -> uint64: +subroutine main: + main_block@0: + // structure_methods/contract.py:69 + // class TestContract(ARC4Contract): + txn NumAppArgs tmp%0#1 + v-store tmp%0#1 + v-load tmp%0#1 tmp%0#1 + bz main___algopy_default_create@5 ; b main_abi_routing@2 + + main_abi_routing@2: + // structure_methods/contract.py:69 + // class TestContract(ARC4Contract): + txna ApplicationArgs 0 tmp%2#0 + v-store tmp%2#0 + method test()void Method(test()void) + v-load tmp%2#0 Method(test()void),tmp%2#0 + match main_test_route@3 ; b main_switch_case_next@4 + + main_test_route@3: + // structure_methods/contract.py:70 + // @public + txn OnCompletion tmp%3#0 + v-store tmp%3#0 + v-load tmp%3#0 tmp%3#0 + ! tmp%4#0 + v-store tmp%4#0 + txn ApplicationID tmp%5#0 + v-store tmp%5#0 + v-load tmp%4#0 tmp%4#0 + v-load tmp%5#0 tmp%4#0,tmp%5#0 + && tmp%7#0 + v-store tmp%7#0 + v-load tmp%7#0 tmp%7#0 + assert + callsub test + b main_switch_case_next@4 + + main_switch_case_next@4: + // structure_methods/contract.py:69 + // class TestContract(ARC4Contract): + err + + main___algopy_default_create@5: + txn OnCompletion tmp%8#0 + v-store tmp%8#0 + v-load tmp%8#0 tmp%8#0 + ! tmp%9#0 + v-store tmp%9#0 + txn ApplicationID tmp%10#0 + v-store tmp%10#0 + v-load tmp%10#0 tmp%10#0 + ! tmp%11#0 + v-store tmp%11#0 + v-load tmp%9#0 tmp%9#0 + v-load tmp%11#0 tmp%9#0,tmp%11#0 + && tmp%12#0 + v-store tmp%12#0 + v-load tmp%12#0 tmp%12#0 + assert + int 1 1 + return + + +// test_cases.structure_methods.contract.GroupedMethods.never_inlined_usually_inlined(v: uint64) -> uint64: +subroutine never_inlined_usually_inlined: + never_inlined_usually_inlined_block@0: (𝕡) v#0 | + // structure_methods/contract.py:42 + // return v + UInt64(1) + p-load v#0 (𝕡) v#0 | v#0 (copy) + int 1 (𝕡) v#0 | v#0 (copy),1 + + (𝕡) v#0 | tmp%0#0 + v-store tmp%0#0 (𝕡) v#0 | + v-load tmp%0#0 (𝕡) v#0 | tmp%0#0 + retsub tmp%0#0 + + +// test_cases.structure_methods.contract.GroupedMethods.not_usually_inlined(v: uint64) -> void: +subroutine not_usually_inlined: + not_usually_inlined_block@0: (𝕡) v#0 | + // structure_methods/contract.py:59 + // arc4.emit(ARC4TestStruct(arc4.UInt64(v))) + p-load v#0 (𝕡) v#0 | v#0 (copy) + itob (𝕡) v#0 | aggregate%val_as_bytes%0#0 + v-store aggregate%val_as_bytes%0#0 (𝕡) v#0 | + method ARC4TestStruct(uint64) (𝕡) v#0 | Method(ARC4TestStruct(uint64)) + v-load aggregate%val_as_bytes%0#0 (𝕡) v#0 | Method(ARC4TestStruct(uint64)),aggregate%val_as_bytes%0#0 + concat (𝕡) v#0 | event%0#0 + v-store event%0#0 (𝕡) v#0 | + v-load event%0#0 (𝕡) v#0 | event%0#0 + log (𝕡) v#0 | + // structure_methods/contract.py:60 + // arc4.emit(ARC4TestStruct(arc4.UInt64(v))) + v-load event%0#0 (𝕡) v#0 | event%0#0 + log (𝕡) v#0 | + // structure_methods/contract.py:61 + // arc4.emit(ARC4TestStruct(arc4.UInt64(v))) + v-load event%0#0 (𝕡) v#0 | event%0#0 + log (𝕡) v#0 | + // structure_methods/contract.py:62 + // arc4.emit(ARC4TestStruct(arc4.UInt64(v))) + v-load event%0#0 (𝕡) v#0 | event%0#0 + log (𝕡) v#0 | + // structure_methods/contract.py:63 + // arc4.emit(ARC4TestStruct(arc4.UInt64(v))) + v-load event%0#0 (𝕡) v#0 | event%0#0 + log (𝕡) v#0 | + // structure_methods/contract.py:64 + // arc4.emit(ARC4TestStruct(arc4.UInt64(v))) + v-load event%0#0 (𝕡) v#0 | event%0#0 + log (𝕡) v#0 | + // structure_methods/contract.py:65 + // arc4.emit(ARC4TestStruct(arc4.UInt64(v))) + v-load event%0#0 (𝕡) v#0 | event%0#0 + log (𝕡) v#0 | + // structure_methods/contract.py:66 + // arc4.emit(ARC4TestStruct(arc4.UInt64(v))) + v-load event%0#0 (𝕡) v#0 | event%0#0 + log (𝕡) v#0 | + retsub + + +// test_cases.structure_methods.contract.TestContract.test[routing]() -> void: +subroutine test: + test_block@0: + // structure_methods/contract.py:101 + // assert UInt64(3) == GroupedMethods().never_inlined_usually_inlined(UInt64(2)) + int 2 2 + callsub never_inlined_usually_inlined tmp%24#0 + v-store tmp%24#0 + int 3 3 + v-load tmp%24#0 3,tmp%24#0 + == tmp%25#0 + v-store tmp%25#0 + v-load tmp%25#0 tmp%25#0 + assert + // structure_methods/contract.py:102 + // assert UInt64(3) == GroupedMethods().never_inlined_usually_inlined(UInt64(2)) + int 2 2 + callsub never_inlined_usually_inlined tmp%26#0 + v-store tmp%26#0 + int 3 3 + v-load tmp%26#0 3,tmp%26#0 + == tmp%27#0 + v-store tmp%27#0 + v-load tmp%27#0 tmp%27#0 + assert + // structure_methods/contract.py:46 + // arc4.emit(ARC4TestStruct(arc4.UInt64(v))) + byte 0xed3267e80000000000000002 0xed3267e80000000000000002 + log + byte 0xed3267e80000000000000002 0xed3267e80000000000000002 + // structure_methods/contract.py:47 + // arc4.emit(ARC4TestStruct(arc4.UInt64(v))) + log + // structure_methods/contract.py:46 + // arc4.emit(ARC4TestStruct(arc4.UInt64(v))) + byte 0xed3267e80000000000000002 0xed3267e80000000000000002 + // structure_methods/contract.py:48 + // arc4.emit(ARC4TestStruct(arc4.UInt64(v))) + log + // structure_methods/contract.py:46 + // arc4.emit(ARC4TestStruct(arc4.UInt64(v))) + byte 0xed3267e80000000000000002 0xed3267e80000000000000002 + // structure_methods/contract.py:49 + // arc4.emit(ARC4TestStruct(arc4.UInt64(v))) + log + // structure_methods/contract.py:46 + // arc4.emit(ARC4TestStruct(arc4.UInt64(v))) + byte 0xed3267e80000000000000002 0xed3267e80000000000000002 + // structure_methods/contract.py:50 + // arc4.emit(ARC4TestStruct(arc4.UInt64(v))) + log + // structure_methods/contract.py:46 + // arc4.emit(ARC4TestStruct(arc4.UInt64(v))) + byte 0xed3267e80000000000000002 0xed3267e80000000000000002 + // structure_methods/contract.py:51 + // arc4.emit(ARC4TestStruct(arc4.UInt64(v))) + log + // structure_methods/contract.py:46 + // arc4.emit(ARC4TestStruct(arc4.UInt64(v))) + byte 0xed3267e80000000000000002 0xed3267e80000000000000002 + // structure_methods/contract.py:52 + // arc4.emit(ARC4TestStruct(arc4.UInt64(v))) + log + // structure_methods/contract.py:46 + // arc4.emit(ARC4TestStruct(arc4.UInt64(v))) + byte 0xed3267e80000000000000002 0xed3267e80000000000000002 + // structure_methods/contract.py:53 + // arc4.emit(ARC4TestStruct(arc4.UInt64(v))) + log + // structure_methods/contract.py:46 + // arc4.emit(ARC4TestStruct(arc4.UInt64(v))) + byte 0xed3267e80000000000000002 0xed3267e80000000000000002 + log + byte 0xed3267e80000000000000002 0xed3267e80000000000000002 + // structure_methods/contract.py:47 + // arc4.emit(ARC4TestStruct(arc4.UInt64(v))) + log + // structure_methods/contract.py:46 + // arc4.emit(ARC4TestStruct(arc4.UInt64(v))) + byte 0xed3267e80000000000000002 0xed3267e80000000000000002 + // structure_methods/contract.py:48 + // arc4.emit(ARC4TestStruct(arc4.UInt64(v))) + log + // structure_methods/contract.py:46 + // arc4.emit(ARC4TestStruct(arc4.UInt64(v))) + byte 0xed3267e80000000000000002 0xed3267e80000000000000002 + // structure_methods/contract.py:49 + // arc4.emit(ARC4TestStruct(arc4.UInt64(v))) + log + // structure_methods/contract.py:46 + // arc4.emit(ARC4TestStruct(arc4.UInt64(v))) + byte 0xed3267e80000000000000002 0xed3267e80000000000000002 + // structure_methods/contract.py:50 + // arc4.emit(ARC4TestStruct(arc4.UInt64(v))) + log + // structure_methods/contract.py:46 + // arc4.emit(ARC4TestStruct(arc4.UInt64(v))) + byte 0xed3267e80000000000000002 0xed3267e80000000000000002 + // structure_methods/contract.py:51 + // arc4.emit(ARC4TestStruct(arc4.UInt64(v))) + log + // structure_methods/contract.py:46 + // arc4.emit(ARC4TestStruct(arc4.UInt64(v))) + byte 0xed3267e80000000000000002 0xed3267e80000000000000002 + // structure_methods/contract.py:52 + // arc4.emit(ARC4TestStruct(arc4.UInt64(v))) + log + // structure_methods/contract.py:46 + // arc4.emit(ARC4TestStruct(arc4.UInt64(v))) + byte 0xed3267e80000000000000002 0xed3267e80000000000000002 + // structure_methods/contract.py:53 + // arc4.emit(ARC4TestStruct(arc4.UInt64(v))) + log + // structure_methods/contract.py:107 + // GroupedMethods().not_usually_inlined(UInt64(2)) + int 2 2 + callsub not_usually_inlined + // structure_methods/contract.py:108 + // GroupedMethods().not_usually_inlined(UInt64(2)) + int 2 2 + callsub not_usually_inlined + // structure_methods/contract.py:70 + // @public + int 1 1 + return + + diff --git a/test_cases/structure_methods/out/TestContract.ir/TestContract.approval.501.lstack.mir b/test_cases/structure_methods/out/TestContract.ir/TestContract.approval.501.lstack.mir new file mode 100644 index 0000000000..c3d9863063 --- /dev/null +++ b/test_cases/structure_methods/out/TestContract.ir/TestContract.approval.501.lstack.mir @@ -0,0 +1,232 @@ +// Op Stack (out) +// algopy.arc4.ARC4Contract.approval_program() -> uint64: +subroutine main: + main_block@0: + // structure_methods/contract.py:69 + // class TestContract(ARC4Contract): + txn NumAppArgs tmp%0#1 + l-load tmp%0#1 0 tmp%0#1 + bz main___algopy_default_create@5 ; b main_abi_routing@2 + + main_abi_routing@2: + // structure_methods/contract.py:69 + // class TestContract(ARC4Contract): + txna ApplicationArgs 0 tmp%2#0 + method test()void tmp%2#0,Method(test()void) + l-load tmp%2#0 1 Method(test()void),tmp%2#0 + match main_test_route@3 ; b main_switch_case_next@4 + + main_test_route@3: + // structure_methods/contract.py:70 + // @public + txn OnCompletion tmp%3#0 + l-load tmp%3#0 0 tmp%3#0 + ! tmp%4#0 + txn ApplicationID tmp%4#0,tmp%5#0 + l-load tmp%4#0 1 tmp%5#0,tmp%4#0 + l-load tmp%5#0 1 tmp%4#0,tmp%5#0 + && tmp%7#0 + l-load tmp%7#0 0 tmp%7#0 + assert + callsub test + b main_switch_case_next@4 + + main_switch_case_next@4: + // structure_methods/contract.py:69 + // class TestContract(ARC4Contract): + err + + main___algopy_default_create@5: + txn OnCompletion tmp%8#0 + l-load tmp%8#0 0 tmp%8#0 + ! tmp%9#0 + txn ApplicationID tmp%9#0,tmp%10#0 + l-load tmp%10#0 0 tmp%9#0,tmp%10#0 + ! tmp%9#0,tmp%11#0 + l-load tmp%9#0 1 tmp%11#0,tmp%9#0 + l-load tmp%11#0 1 tmp%9#0,tmp%11#0 + && tmp%12#0 + l-load tmp%12#0 0 tmp%12#0 + assert + int 1 1 + return + + +// test_cases.structure_methods.contract.GroupedMethods.never_inlined_usually_inlined(v: uint64) -> uint64: +subroutine never_inlined_usually_inlined: + never_inlined_usually_inlined_block@0: (𝕡) v#0 | + // structure_methods/contract.py:42 + // return v + UInt64(1) + p-load v#0 (𝕡) v#0 | v#0 (copy) + int 1 (𝕡) v#0 | v#0 (copy),1 + + (𝕡) v#0 | tmp%0#0 + l-load tmp%0#0 0 (𝕡) v#0 | tmp%0#0 + retsub tmp%0#0 + + +// test_cases.structure_methods.contract.GroupedMethods.not_usually_inlined(v: uint64) -> void: +subroutine not_usually_inlined: + not_usually_inlined_block@0: (𝕡) v#0 | + // structure_methods/contract.py:59 + // arc4.emit(ARC4TestStruct(arc4.UInt64(v))) + p-load v#0 (𝕡) v#0 | v#0 (copy) + itob (𝕡) v#0 | aggregate%val_as_bytes%0#0 + method ARC4TestStruct(uint64) (𝕡) v#0 | aggregate%val_as_bytes%0#0,Method(ARC4TestStruct(uint64)) + l-load aggregate%val_as_bytes%0#0 1 (𝕡) v#0 | Method(ARC4TestStruct(uint64)),aggregate%val_as_bytes%0#0 + concat (𝕡) v#0 | event%0#0 + l-load-copy event%0#0 0 (𝕡) v#0 | event%0#0,event%0#0 (copy) + log (𝕡) v#0 | event%0#0 + // structure_methods/contract.py:60 + // arc4.emit(ARC4TestStruct(arc4.UInt64(v))) + l-load-copy event%0#0 0 (𝕡) v#0 | event%0#0,event%0#0 (copy) + log (𝕡) v#0 | event%0#0 + // structure_methods/contract.py:61 + // arc4.emit(ARC4TestStruct(arc4.UInt64(v))) + l-load-copy event%0#0 0 (𝕡) v#0 | event%0#0,event%0#0 (copy) + log (𝕡) v#0 | event%0#0 + // structure_methods/contract.py:62 + // arc4.emit(ARC4TestStruct(arc4.UInt64(v))) + l-load-copy event%0#0 0 (𝕡) v#0 | event%0#0,event%0#0 (copy) + log (𝕡) v#0 | event%0#0 + // structure_methods/contract.py:63 + // arc4.emit(ARC4TestStruct(arc4.UInt64(v))) + l-load-copy event%0#0 0 (𝕡) v#0 | event%0#0,event%0#0 (copy) + log (𝕡) v#0 | event%0#0 + // structure_methods/contract.py:64 + // arc4.emit(ARC4TestStruct(arc4.UInt64(v))) + l-load-copy event%0#0 0 (𝕡) v#0 | event%0#0,event%0#0 (copy) + log (𝕡) v#0 | event%0#0 + // structure_methods/contract.py:65 + // arc4.emit(ARC4TestStruct(arc4.UInt64(v))) + l-load-copy event%0#0 0 (𝕡) v#0 | event%0#0,event%0#0 (copy) + log (𝕡) v#0 | event%0#0 + // structure_methods/contract.py:66 + // arc4.emit(ARC4TestStruct(arc4.UInt64(v))) + l-load event%0#0 0 (𝕡) v#0 | event%0#0 + log (𝕡) v#0 | + retsub + + +// test_cases.structure_methods.contract.TestContract.test[routing]() -> void: +subroutine test: + test_block@0: + // structure_methods/contract.py:101 + // assert UInt64(3) == GroupedMethods().never_inlined_usually_inlined(UInt64(2)) + int 2 2 + callsub never_inlined_usually_inlined tmp%24#0 + int 3 tmp%24#0,3 + l-load tmp%24#0 1 3,tmp%24#0 + == tmp%25#0 + l-load tmp%25#0 0 tmp%25#0 + assert + // structure_methods/contract.py:102 + // assert UInt64(3) == GroupedMethods().never_inlined_usually_inlined(UInt64(2)) + int 2 2 + callsub never_inlined_usually_inlined tmp%26#0 + int 3 tmp%26#0,3 + l-load tmp%26#0 1 3,tmp%26#0 + == tmp%27#0 + l-load tmp%27#0 0 tmp%27#0 + assert + // structure_methods/contract.py:46 + // arc4.emit(ARC4TestStruct(arc4.UInt64(v))) + byte 0xed3267e80000000000000002 0xed3267e80000000000000002 + log + byte 0xed3267e80000000000000002 0xed3267e80000000000000002 + // structure_methods/contract.py:47 + // arc4.emit(ARC4TestStruct(arc4.UInt64(v))) + log + // structure_methods/contract.py:46 + // arc4.emit(ARC4TestStruct(arc4.UInt64(v))) + byte 0xed3267e80000000000000002 0xed3267e80000000000000002 + // structure_methods/contract.py:48 + // arc4.emit(ARC4TestStruct(arc4.UInt64(v))) + log + // structure_methods/contract.py:46 + // arc4.emit(ARC4TestStruct(arc4.UInt64(v))) + byte 0xed3267e80000000000000002 0xed3267e80000000000000002 + // structure_methods/contract.py:49 + // arc4.emit(ARC4TestStruct(arc4.UInt64(v))) + log + // structure_methods/contract.py:46 + // arc4.emit(ARC4TestStruct(arc4.UInt64(v))) + byte 0xed3267e80000000000000002 0xed3267e80000000000000002 + // structure_methods/contract.py:50 + // arc4.emit(ARC4TestStruct(arc4.UInt64(v))) + log + // structure_methods/contract.py:46 + // arc4.emit(ARC4TestStruct(arc4.UInt64(v))) + byte 0xed3267e80000000000000002 0xed3267e80000000000000002 + // structure_methods/contract.py:51 + // arc4.emit(ARC4TestStruct(arc4.UInt64(v))) + log + // structure_methods/contract.py:46 + // arc4.emit(ARC4TestStruct(arc4.UInt64(v))) + byte 0xed3267e80000000000000002 0xed3267e80000000000000002 + // structure_methods/contract.py:52 + // arc4.emit(ARC4TestStruct(arc4.UInt64(v))) + log + // structure_methods/contract.py:46 + // arc4.emit(ARC4TestStruct(arc4.UInt64(v))) + byte 0xed3267e80000000000000002 0xed3267e80000000000000002 + // structure_methods/contract.py:53 + // arc4.emit(ARC4TestStruct(arc4.UInt64(v))) + log + // structure_methods/contract.py:46 + // arc4.emit(ARC4TestStruct(arc4.UInt64(v))) + byte 0xed3267e80000000000000002 0xed3267e80000000000000002 + log + byte 0xed3267e80000000000000002 0xed3267e80000000000000002 + // structure_methods/contract.py:47 + // arc4.emit(ARC4TestStruct(arc4.UInt64(v))) + log + // structure_methods/contract.py:46 + // arc4.emit(ARC4TestStruct(arc4.UInt64(v))) + byte 0xed3267e80000000000000002 0xed3267e80000000000000002 + // structure_methods/contract.py:48 + // arc4.emit(ARC4TestStruct(arc4.UInt64(v))) + log + // structure_methods/contract.py:46 + // arc4.emit(ARC4TestStruct(arc4.UInt64(v))) + byte 0xed3267e80000000000000002 0xed3267e80000000000000002 + // structure_methods/contract.py:49 + // arc4.emit(ARC4TestStruct(arc4.UInt64(v))) + log + // structure_methods/contract.py:46 + // arc4.emit(ARC4TestStruct(arc4.UInt64(v))) + byte 0xed3267e80000000000000002 0xed3267e80000000000000002 + // structure_methods/contract.py:50 + // arc4.emit(ARC4TestStruct(arc4.UInt64(v))) + log + // structure_methods/contract.py:46 + // arc4.emit(ARC4TestStruct(arc4.UInt64(v))) + byte 0xed3267e80000000000000002 0xed3267e80000000000000002 + // structure_methods/contract.py:51 + // arc4.emit(ARC4TestStruct(arc4.UInt64(v))) + log + // structure_methods/contract.py:46 + // arc4.emit(ARC4TestStruct(arc4.UInt64(v))) + byte 0xed3267e80000000000000002 0xed3267e80000000000000002 + // structure_methods/contract.py:52 + // arc4.emit(ARC4TestStruct(arc4.UInt64(v))) + log + // structure_methods/contract.py:46 + // arc4.emit(ARC4TestStruct(arc4.UInt64(v))) + byte 0xed3267e80000000000000002 0xed3267e80000000000000002 + // structure_methods/contract.py:53 + // arc4.emit(ARC4TestStruct(arc4.UInt64(v))) + log + // structure_methods/contract.py:107 + // GroupedMethods().not_usually_inlined(UInt64(2)) + int 2 2 + callsub not_usually_inlined + // structure_methods/contract.py:108 + // GroupedMethods().not_usually_inlined(UInt64(2)) + int 2 2 + callsub not_usually_inlined + // structure_methods/contract.py:70 + // @public + int 1 1 + return + + diff --git a/test_cases/structure_methods/out/TestContract.ir/TestContract.approval.502.lstack.opt.mir b/test_cases/structure_methods/out/TestContract.ir/TestContract.approval.502.lstack.opt.mir new file mode 100644 index 0000000000..f2b185ca94 --- /dev/null +++ b/test_cases/structure_methods/out/TestContract.ir/TestContract.approval.502.lstack.opt.mir @@ -0,0 +1,223 @@ +// Op Stack (out) +// algopy.arc4.ARC4Contract.approval_program() -> uint64: +subroutine main: + main_block@0: + // structure_methods/contract.py:69 + // class TestContract(ARC4Contract): + txn NumAppArgs tmp%0#1 + bz main___algopy_default_create@5 ; b main_abi_routing@2 + + main_abi_routing@2: + // structure_methods/contract.py:69 + // class TestContract(ARC4Contract): + txna ApplicationArgs 0 tmp%2#0 + method test()void tmp%2#0,Method(test()void) + l-load tmp%2#0 1 Method(test()void),tmp%2#0 + match main_test_route@3 ; b main_switch_case_next@4 + + main_test_route@3: + // structure_methods/contract.py:70 + // @public + txn OnCompletion tmp%3#0 + ! tmp%4#0 + txn ApplicationID tmp%4#0,tmp%5#0 + l-load tmp%4#0 1 tmp%5#0,tmp%4#0 + l-load tmp%5#0 1 tmp%4#0,tmp%5#0 + && tmp%7#0 + assert + callsub test + b main_switch_case_next@4 + + main_switch_case_next@4: + // structure_methods/contract.py:69 + // class TestContract(ARC4Contract): + err + + main___algopy_default_create@5: + txn OnCompletion tmp%8#0 + ! tmp%9#0 + txn ApplicationID tmp%9#0,tmp%10#0 + ! tmp%9#0,tmp%11#0 + l-load tmp%9#0 1 tmp%11#0,tmp%9#0 + l-load tmp%11#0 1 tmp%9#0,tmp%11#0 + && tmp%12#0 + assert + int 1 1 + return + + +// test_cases.structure_methods.contract.GroupedMethods.never_inlined_usually_inlined(v: uint64) -> uint64: +subroutine never_inlined_usually_inlined: + never_inlined_usually_inlined_block@0: (𝕡) v#0 | + // structure_methods/contract.py:42 + // return v + UInt64(1) + p-load v#0 (𝕡) v#0 | v#0 (copy) + int 1 (𝕡) v#0 | v#0 (copy),1 + + (𝕡) v#0 | tmp%0#0 + retsub tmp%0#0 + + +// test_cases.structure_methods.contract.GroupedMethods.not_usually_inlined(v: uint64) -> void: +subroutine not_usually_inlined: + not_usually_inlined_block@0: (𝕡) v#0 | + // structure_methods/contract.py:59 + // arc4.emit(ARC4TestStruct(arc4.UInt64(v))) + p-load v#0 (𝕡) v#0 | v#0 (copy) + itob (𝕡) v#0 | aggregate%val_as_bytes%0#0 + method ARC4TestStruct(uint64) (𝕡) v#0 | aggregate%val_as_bytes%0#0,Method(ARC4TestStruct(uint64)) + l-load aggregate%val_as_bytes%0#0 1 (𝕡) v#0 | Method(ARC4TestStruct(uint64)),aggregate%val_as_bytes%0#0 + concat (𝕡) v#0 | event%0#0 + l-load-copy event%0#0 0 (𝕡) v#0 | event%0#0,event%0#0 (copy) + log (𝕡) v#0 | event%0#0 + // structure_methods/contract.py:60 + // arc4.emit(ARC4TestStruct(arc4.UInt64(v))) + l-load-copy event%0#0 0 (𝕡) v#0 | event%0#0,event%0#0 (copy) + log (𝕡) v#0 | event%0#0 + // structure_methods/contract.py:61 + // arc4.emit(ARC4TestStruct(arc4.UInt64(v))) + l-load-copy event%0#0 0 (𝕡) v#0 | event%0#0,event%0#0 (copy) + log (𝕡) v#0 | event%0#0 + // structure_methods/contract.py:62 + // arc4.emit(ARC4TestStruct(arc4.UInt64(v))) + l-load-copy event%0#0 0 (𝕡) v#0 | event%0#0,event%0#0 (copy) + log (𝕡) v#0 | event%0#0 + // structure_methods/contract.py:63 + // arc4.emit(ARC4TestStruct(arc4.UInt64(v))) + l-load-copy event%0#0 0 (𝕡) v#0 | event%0#0,event%0#0 (copy) + log (𝕡) v#0 | event%0#0 + // structure_methods/contract.py:64 + // arc4.emit(ARC4TestStruct(arc4.UInt64(v))) + l-load-copy event%0#0 0 (𝕡) v#0 | event%0#0,event%0#0 (copy) + log (𝕡) v#0 | event%0#0 + // structure_methods/contract.py:65 + // arc4.emit(ARC4TestStruct(arc4.UInt64(v))) + l-load-copy event%0#0 0 (𝕡) v#0 | event%0#0,event%0#0 (copy) + log (𝕡) v#0 | event%0#0 + // structure_methods/contract.py:66 + // arc4.emit(ARC4TestStruct(arc4.UInt64(v))) + l-load event%0#0 0 (𝕡) v#0 | event%0#0 + log (𝕡) v#0 | + retsub + + +// test_cases.structure_methods.contract.TestContract.test[routing]() -> void: +subroutine test: + test_block@0: + // structure_methods/contract.py:101 + // assert UInt64(3) == GroupedMethods().never_inlined_usually_inlined(UInt64(2)) + int 2 2 + callsub never_inlined_usually_inlined tmp%24#0 + int 3 tmp%24#0,3 + l-load tmp%24#0 1 3,tmp%24#0 + == tmp%25#0 + assert + // structure_methods/contract.py:102 + // assert UInt64(3) == GroupedMethods().never_inlined_usually_inlined(UInt64(2)) + int 2 2 + callsub never_inlined_usually_inlined tmp%26#0 + int 3 tmp%26#0,3 + l-load tmp%26#0 1 3,tmp%26#0 + == tmp%27#0 + assert + // structure_methods/contract.py:46 + // arc4.emit(ARC4TestStruct(arc4.UInt64(v))) + byte 0xed3267e80000000000000002 0xed3267e80000000000000002 + log + byte 0xed3267e80000000000000002 0xed3267e80000000000000002 + // structure_methods/contract.py:47 + // arc4.emit(ARC4TestStruct(arc4.UInt64(v))) + log + // structure_methods/contract.py:46 + // arc4.emit(ARC4TestStruct(arc4.UInt64(v))) + byte 0xed3267e80000000000000002 0xed3267e80000000000000002 + // structure_methods/contract.py:48 + // arc4.emit(ARC4TestStruct(arc4.UInt64(v))) + log + // structure_methods/contract.py:46 + // arc4.emit(ARC4TestStruct(arc4.UInt64(v))) + byte 0xed3267e80000000000000002 0xed3267e80000000000000002 + // structure_methods/contract.py:49 + // arc4.emit(ARC4TestStruct(arc4.UInt64(v))) + log + // structure_methods/contract.py:46 + // arc4.emit(ARC4TestStruct(arc4.UInt64(v))) + byte 0xed3267e80000000000000002 0xed3267e80000000000000002 + // structure_methods/contract.py:50 + // arc4.emit(ARC4TestStruct(arc4.UInt64(v))) + log + // structure_methods/contract.py:46 + // arc4.emit(ARC4TestStruct(arc4.UInt64(v))) + byte 0xed3267e80000000000000002 0xed3267e80000000000000002 + // structure_methods/contract.py:51 + // arc4.emit(ARC4TestStruct(arc4.UInt64(v))) + log + // structure_methods/contract.py:46 + // arc4.emit(ARC4TestStruct(arc4.UInt64(v))) + byte 0xed3267e80000000000000002 0xed3267e80000000000000002 + // structure_methods/contract.py:52 + // arc4.emit(ARC4TestStruct(arc4.UInt64(v))) + log + // structure_methods/contract.py:46 + // arc4.emit(ARC4TestStruct(arc4.UInt64(v))) + byte 0xed3267e80000000000000002 0xed3267e80000000000000002 + // structure_methods/contract.py:53 + // arc4.emit(ARC4TestStruct(arc4.UInt64(v))) + log + // structure_methods/contract.py:46 + // arc4.emit(ARC4TestStruct(arc4.UInt64(v))) + byte 0xed3267e80000000000000002 0xed3267e80000000000000002 + log + byte 0xed3267e80000000000000002 0xed3267e80000000000000002 + // structure_methods/contract.py:47 + // arc4.emit(ARC4TestStruct(arc4.UInt64(v))) + log + // structure_methods/contract.py:46 + // arc4.emit(ARC4TestStruct(arc4.UInt64(v))) + byte 0xed3267e80000000000000002 0xed3267e80000000000000002 + // structure_methods/contract.py:48 + // arc4.emit(ARC4TestStruct(arc4.UInt64(v))) + log + // structure_methods/contract.py:46 + // arc4.emit(ARC4TestStruct(arc4.UInt64(v))) + byte 0xed3267e80000000000000002 0xed3267e80000000000000002 + // structure_methods/contract.py:49 + // arc4.emit(ARC4TestStruct(arc4.UInt64(v))) + log + // structure_methods/contract.py:46 + // arc4.emit(ARC4TestStruct(arc4.UInt64(v))) + byte 0xed3267e80000000000000002 0xed3267e80000000000000002 + // structure_methods/contract.py:50 + // arc4.emit(ARC4TestStruct(arc4.UInt64(v))) + log + // structure_methods/contract.py:46 + // arc4.emit(ARC4TestStruct(arc4.UInt64(v))) + byte 0xed3267e80000000000000002 0xed3267e80000000000000002 + // structure_methods/contract.py:51 + // arc4.emit(ARC4TestStruct(arc4.UInt64(v))) + log + // structure_methods/contract.py:46 + // arc4.emit(ARC4TestStruct(arc4.UInt64(v))) + byte 0xed3267e80000000000000002 0xed3267e80000000000000002 + // structure_methods/contract.py:52 + // arc4.emit(ARC4TestStruct(arc4.UInt64(v))) + log + // structure_methods/contract.py:46 + // arc4.emit(ARC4TestStruct(arc4.UInt64(v))) + byte 0xed3267e80000000000000002 0xed3267e80000000000000002 + // structure_methods/contract.py:53 + // arc4.emit(ARC4TestStruct(arc4.UInt64(v))) + log + // structure_methods/contract.py:107 + // GroupedMethods().not_usually_inlined(UInt64(2)) + int 2 2 + callsub not_usually_inlined + // structure_methods/contract.py:108 + // GroupedMethods().not_usually_inlined(UInt64(2)) + int 2 2 + callsub not_usually_inlined + // structure_methods/contract.py:70 + // @public + int 1 1 + return + + diff --git a/test_cases/structure_methods/out/TestContract.ir/TestContract.approval.503.xstack.mir b/test_cases/structure_methods/out/TestContract.ir/TestContract.approval.503.xstack.mir new file mode 100644 index 0000000000..f2b185ca94 --- /dev/null +++ b/test_cases/structure_methods/out/TestContract.ir/TestContract.approval.503.xstack.mir @@ -0,0 +1,223 @@ +// Op Stack (out) +// algopy.arc4.ARC4Contract.approval_program() -> uint64: +subroutine main: + main_block@0: + // structure_methods/contract.py:69 + // class TestContract(ARC4Contract): + txn NumAppArgs tmp%0#1 + bz main___algopy_default_create@5 ; b main_abi_routing@2 + + main_abi_routing@2: + // structure_methods/contract.py:69 + // class TestContract(ARC4Contract): + txna ApplicationArgs 0 tmp%2#0 + method test()void tmp%2#0,Method(test()void) + l-load tmp%2#0 1 Method(test()void),tmp%2#0 + match main_test_route@3 ; b main_switch_case_next@4 + + main_test_route@3: + // structure_methods/contract.py:70 + // @public + txn OnCompletion tmp%3#0 + ! tmp%4#0 + txn ApplicationID tmp%4#0,tmp%5#0 + l-load tmp%4#0 1 tmp%5#0,tmp%4#0 + l-load tmp%5#0 1 tmp%4#0,tmp%5#0 + && tmp%7#0 + assert + callsub test + b main_switch_case_next@4 + + main_switch_case_next@4: + // structure_methods/contract.py:69 + // class TestContract(ARC4Contract): + err + + main___algopy_default_create@5: + txn OnCompletion tmp%8#0 + ! tmp%9#0 + txn ApplicationID tmp%9#0,tmp%10#0 + ! tmp%9#0,tmp%11#0 + l-load tmp%9#0 1 tmp%11#0,tmp%9#0 + l-load tmp%11#0 1 tmp%9#0,tmp%11#0 + && tmp%12#0 + assert + int 1 1 + return + + +// test_cases.structure_methods.contract.GroupedMethods.never_inlined_usually_inlined(v: uint64) -> uint64: +subroutine never_inlined_usually_inlined: + never_inlined_usually_inlined_block@0: (𝕡) v#0 | + // structure_methods/contract.py:42 + // return v + UInt64(1) + p-load v#0 (𝕡) v#0 | v#0 (copy) + int 1 (𝕡) v#0 | v#0 (copy),1 + + (𝕡) v#0 | tmp%0#0 + retsub tmp%0#0 + + +// test_cases.structure_methods.contract.GroupedMethods.not_usually_inlined(v: uint64) -> void: +subroutine not_usually_inlined: + not_usually_inlined_block@0: (𝕡) v#0 | + // structure_methods/contract.py:59 + // arc4.emit(ARC4TestStruct(arc4.UInt64(v))) + p-load v#0 (𝕡) v#0 | v#0 (copy) + itob (𝕡) v#0 | aggregate%val_as_bytes%0#0 + method ARC4TestStruct(uint64) (𝕡) v#0 | aggregate%val_as_bytes%0#0,Method(ARC4TestStruct(uint64)) + l-load aggregate%val_as_bytes%0#0 1 (𝕡) v#0 | Method(ARC4TestStruct(uint64)),aggregate%val_as_bytes%0#0 + concat (𝕡) v#0 | event%0#0 + l-load-copy event%0#0 0 (𝕡) v#0 | event%0#0,event%0#0 (copy) + log (𝕡) v#0 | event%0#0 + // structure_methods/contract.py:60 + // arc4.emit(ARC4TestStruct(arc4.UInt64(v))) + l-load-copy event%0#0 0 (𝕡) v#0 | event%0#0,event%0#0 (copy) + log (𝕡) v#0 | event%0#0 + // structure_methods/contract.py:61 + // arc4.emit(ARC4TestStruct(arc4.UInt64(v))) + l-load-copy event%0#0 0 (𝕡) v#0 | event%0#0,event%0#0 (copy) + log (𝕡) v#0 | event%0#0 + // structure_methods/contract.py:62 + // arc4.emit(ARC4TestStruct(arc4.UInt64(v))) + l-load-copy event%0#0 0 (𝕡) v#0 | event%0#0,event%0#0 (copy) + log (𝕡) v#0 | event%0#0 + // structure_methods/contract.py:63 + // arc4.emit(ARC4TestStruct(arc4.UInt64(v))) + l-load-copy event%0#0 0 (𝕡) v#0 | event%0#0,event%0#0 (copy) + log (𝕡) v#0 | event%0#0 + // structure_methods/contract.py:64 + // arc4.emit(ARC4TestStruct(arc4.UInt64(v))) + l-load-copy event%0#0 0 (𝕡) v#0 | event%0#0,event%0#0 (copy) + log (𝕡) v#0 | event%0#0 + // structure_methods/contract.py:65 + // arc4.emit(ARC4TestStruct(arc4.UInt64(v))) + l-load-copy event%0#0 0 (𝕡) v#0 | event%0#0,event%0#0 (copy) + log (𝕡) v#0 | event%0#0 + // structure_methods/contract.py:66 + // arc4.emit(ARC4TestStruct(arc4.UInt64(v))) + l-load event%0#0 0 (𝕡) v#0 | event%0#0 + log (𝕡) v#0 | + retsub + + +// test_cases.structure_methods.contract.TestContract.test[routing]() -> void: +subroutine test: + test_block@0: + // structure_methods/contract.py:101 + // assert UInt64(3) == GroupedMethods().never_inlined_usually_inlined(UInt64(2)) + int 2 2 + callsub never_inlined_usually_inlined tmp%24#0 + int 3 tmp%24#0,3 + l-load tmp%24#0 1 3,tmp%24#0 + == tmp%25#0 + assert + // structure_methods/contract.py:102 + // assert UInt64(3) == GroupedMethods().never_inlined_usually_inlined(UInt64(2)) + int 2 2 + callsub never_inlined_usually_inlined tmp%26#0 + int 3 tmp%26#0,3 + l-load tmp%26#0 1 3,tmp%26#0 + == tmp%27#0 + assert + // structure_methods/contract.py:46 + // arc4.emit(ARC4TestStruct(arc4.UInt64(v))) + byte 0xed3267e80000000000000002 0xed3267e80000000000000002 + log + byte 0xed3267e80000000000000002 0xed3267e80000000000000002 + // structure_methods/contract.py:47 + // arc4.emit(ARC4TestStruct(arc4.UInt64(v))) + log + // structure_methods/contract.py:46 + // arc4.emit(ARC4TestStruct(arc4.UInt64(v))) + byte 0xed3267e80000000000000002 0xed3267e80000000000000002 + // structure_methods/contract.py:48 + // arc4.emit(ARC4TestStruct(arc4.UInt64(v))) + log + // structure_methods/contract.py:46 + // arc4.emit(ARC4TestStruct(arc4.UInt64(v))) + byte 0xed3267e80000000000000002 0xed3267e80000000000000002 + // structure_methods/contract.py:49 + // arc4.emit(ARC4TestStruct(arc4.UInt64(v))) + log + // structure_methods/contract.py:46 + // arc4.emit(ARC4TestStruct(arc4.UInt64(v))) + byte 0xed3267e80000000000000002 0xed3267e80000000000000002 + // structure_methods/contract.py:50 + // arc4.emit(ARC4TestStruct(arc4.UInt64(v))) + log + // structure_methods/contract.py:46 + // arc4.emit(ARC4TestStruct(arc4.UInt64(v))) + byte 0xed3267e80000000000000002 0xed3267e80000000000000002 + // structure_methods/contract.py:51 + // arc4.emit(ARC4TestStruct(arc4.UInt64(v))) + log + // structure_methods/contract.py:46 + // arc4.emit(ARC4TestStruct(arc4.UInt64(v))) + byte 0xed3267e80000000000000002 0xed3267e80000000000000002 + // structure_methods/contract.py:52 + // arc4.emit(ARC4TestStruct(arc4.UInt64(v))) + log + // structure_methods/contract.py:46 + // arc4.emit(ARC4TestStruct(arc4.UInt64(v))) + byte 0xed3267e80000000000000002 0xed3267e80000000000000002 + // structure_methods/contract.py:53 + // arc4.emit(ARC4TestStruct(arc4.UInt64(v))) + log + // structure_methods/contract.py:46 + // arc4.emit(ARC4TestStruct(arc4.UInt64(v))) + byte 0xed3267e80000000000000002 0xed3267e80000000000000002 + log + byte 0xed3267e80000000000000002 0xed3267e80000000000000002 + // structure_methods/contract.py:47 + // arc4.emit(ARC4TestStruct(arc4.UInt64(v))) + log + // structure_methods/contract.py:46 + // arc4.emit(ARC4TestStruct(arc4.UInt64(v))) + byte 0xed3267e80000000000000002 0xed3267e80000000000000002 + // structure_methods/contract.py:48 + // arc4.emit(ARC4TestStruct(arc4.UInt64(v))) + log + // structure_methods/contract.py:46 + // arc4.emit(ARC4TestStruct(arc4.UInt64(v))) + byte 0xed3267e80000000000000002 0xed3267e80000000000000002 + // structure_methods/contract.py:49 + // arc4.emit(ARC4TestStruct(arc4.UInt64(v))) + log + // structure_methods/contract.py:46 + // arc4.emit(ARC4TestStruct(arc4.UInt64(v))) + byte 0xed3267e80000000000000002 0xed3267e80000000000000002 + // structure_methods/contract.py:50 + // arc4.emit(ARC4TestStruct(arc4.UInt64(v))) + log + // structure_methods/contract.py:46 + // arc4.emit(ARC4TestStruct(arc4.UInt64(v))) + byte 0xed3267e80000000000000002 0xed3267e80000000000000002 + // structure_methods/contract.py:51 + // arc4.emit(ARC4TestStruct(arc4.UInt64(v))) + log + // structure_methods/contract.py:46 + // arc4.emit(ARC4TestStruct(arc4.UInt64(v))) + byte 0xed3267e80000000000000002 0xed3267e80000000000000002 + // structure_methods/contract.py:52 + // arc4.emit(ARC4TestStruct(arc4.UInt64(v))) + log + // structure_methods/contract.py:46 + // arc4.emit(ARC4TestStruct(arc4.UInt64(v))) + byte 0xed3267e80000000000000002 0xed3267e80000000000000002 + // structure_methods/contract.py:53 + // arc4.emit(ARC4TestStruct(arc4.UInt64(v))) + log + // structure_methods/contract.py:107 + // GroupedMethods().not_usually_inlined(UInt64(2)) + int 2 2 + callsub not_usually_inlined + // structure_methods/contract.py:108 + // GroupedMethods().not_usually_inlined(UInt64(2)) + int 2 2 + callsub not_usually_inlined + // structure_methods/contract.py:70 + // @public + int 1 1 + return + + diff --git a/test_cases/structure_methods/out/TestContract.ir/TestContract.approval.504.xstack.opt.mir b/test_cases/structure_methods/out/TestContract.ir/TestContract.approval.504.xstack.opt.mir new file mode 100644 index 0000000000..f2b185ca94 --- /dev/null +++ b/test_cases/structure_methods/out/TestContract.ir/TestContract.approval.504.xstack.opt.mir @@ -0,0 +1,223 @@ +// Op Stack (out) +// algopy.arc4.ARC4Contract.approval_program() -> uint64: +subroutine main: + main_block@0: + // structure_methods/contract.py:69 + // class TestContract(ARC4Contract): + txn NumAppArgs tmp%0#1 + bz main___algopy_default_create@5 ; b main_abi_routing@2 + + main_abi_routing@2: + // structure_methods/contract.py:69 + // class TestContract(ARC4Contract): + txna ApplicationArgs 0 tmp%2#0 + method test()void tmp%2#0,Method(test()void) + l-load tmp%2#0 1 Method(test()void),tmp%2#0 + match main_test_route@3 ; b main_switch_case_next@4 + + main_test_route@3: + // structure_methods/contract.py:70 + // @public + txn OnCompletion tmp%3#0 + ! tmp%4#0 + txn ApplicationID tmp%4#0,tmp%5#0 + l-load tmp%4#0 1 tmp%5#0,tmp%4#0 + l-load tmp%5#0 1 tmp%4#0,tmp%5#0 + && tmp%7#0 + assert + callsub test + b main_switch_case_next@4 + + main_switch_case_next@4: + // structure_methods/contract.py:69 + // class TestContract(ARC4Contract): + err + + main___algopy_default_create@5: + txn OnCompletion tmp%8#0 + ! tmp%9#0 + txn ApplicationID tmp%9#0,tmp%10#0 + ! tmp%9#0,tmp%11#0 + l-load tmp%9#0 1 tmp%11#0,tmp%9#0 + l-load tmp%11#0 1 tmp%9#0,tmp%11#0 + && tmp%12#0 + assert + int 1 1 + return + + +// test_cases.structure_methods.contract.GroupedMethods.never_inlined_usually_inlined(v: uint64) -> uint64: +subroutine never_inlined_usually_inlined: + never_inlined_usually_inlined_block@0: (𝕡) v#0 | + // structure_methods/contract.py:42 + // return v + UInt64(1) + p-load v#0 (𝕡) v#0 | v#0 (copy) + int 1 (𝕡) v#0 | v#0 (copy),1 + + (𝕡) v#0 | tmp%0#0 + retsub tmp%0#0 + + +// test_cases.structure_methods.contract.GroupedMethods.not_usually_inlined(v: uint64) -> void: +subroutine not_usually_inlined: + not_usually_inlined_block@0: (𝕡) v#0 | + // structure_methods/contract.py:59 + // arc4.emit(ARC4TestStruct(arc4.UInt64(v))) + p-load v#0 (𝕡) v#0 | v#0 (copy) + itob (𝕡) v#0 | aggregate%val_as_bytes%0#0 + method ARC4TestStruct(uint64) (𝕡) v#0 | aggregate%val_as_bytes%0#0,Method(ARC4TestStruct(uint64)) + l-load aggregate%val_as_bytes%0#0 1 (𝕡) v#0 | Method(ARC4TestStruct(uint64)),aggregate%val_as_bytes%0#0 + concat (𝕡) v#0 | event%0#0 + l-load-copy event%0#0 0 (𝕡) v#0 | event%0#0,event%0#0 (copy) + log (𝕡) v#0 | event%0#0 + // structure_methods/contract.py:60 + // arc4.emit(ARC4TestStruct(arc4.UInt64(v))) + l-load-copy event%0#0 0 (𝕡) v#0 | event%0#0,event%0#0 (copy) + log (𝕡) v#0 | event%0#0 + // structure_methods/contract.py:61 + // arc4.emit(ARC4TestStruct(arc4.UInt64(v))) + l-load-copy event%0#0 0 (𝕡) v#0 | event%0#0,event%0#0 (copy) + log (𝕡) v#0 | event%0#0 + // structure_methods/contract.py:62 + // arc4.emit(ARC4TestStruct(arc4.UInt64(v))) + l-load-copy event%0#0 0 (𝕡) v#0 | event%0#0,event%0#0 (copy) + log (𝕡) v#0 | event%0#0 + // structure_methods/contract.py:63 + // arc4.emit(ARC4TestStruct(arc4.UInt64(v))) + l-load-copy event%0#0 0 (𝕡) v#0 | event%0#0,event%0#0 (copy) + log (𝕡) v#0 | event%0#0 + // structure_methods/contract.py:64 + // arc4.emit(ARC4TestStruct(arc4.UInt64(v))) + l-load-copy event%0#0 0 (𝕡) v#0 | event%0#0,event%0#0 (copy) + log (𝕡) v#0 | event%0#0 + // structure_methods/contract.py:65 + // arc4.emit(ARC4TestStruct(arc4.UInt64(v))) + l-load-copy event%0#0 0 (𝕡) v#0 | event%0#0,event%0#0 (copy) + log (𝕡) v#0 | event%0#0 + // structure_methods/contract.py:66 + // arc4.emit(ARC4TestStruct(arc4.UInt64(v))) + l-load event%0#0 0 (𝕡) v#0 | event%0#0 + log (𝕡) v#0 | + retsub + + +// test_cases.structure_methods.contract.TestContract.test[routing]() -> void: +subroutine test: + test_block@0: + // structure_methods/contract.py:101 + // assert UInt64(3) == GroupedMethods().never_inlined_usually_inlined(UInt64(2)) + int 2 2 + callsub never_inlined_usually_inlined tmp%24#0 + int 3 tmp%24#0,3 + l-load tmp%24#0 1 3,tmp%24#0 + == tmp%25#0 + assert + // structure_methods/contract.py:102 + // assert UInt64(3) == GroupedMethods().never_inlined_usually_inlined(UInt64(2)) + int 2 2 + callsub never_inlined_usually_inlined tmp%26#0 + int 3 tmp%26#0,3 + l-load tmp%26#0 1 3,tmp%26#0 + == tmp%27#0 + assert + // structure_methods/contract.py:46 + // arc4.emit(ARC4TestStruct(arc4.UInt64(v))) + byte 0xed3267e80000000000000002 0xed3267e80000000000000002 + log + byte 0xed3267e80000000000000002 0xed3267e80000000000000002 + // structure_methods/contract.py:47 + // arc4.emit(ARC4TestStruct(arc4.UInt64(v))) + log + // structure_methods/contract.py:46 + // arc4.emit(ARC4TestStruct(arc4.UInt64(v))) + byte 0xed3267e80000000000000002 0xed3267e80000000000000002 + // structure_methods/contract.py:48 + // arc4.emit(ARC4TestStruct(arc4.UInt64(v))) + log + // structure_methods/contract.py:46 + // arc4.emit(ARC4TestStruct(arc4.UInt64(v))) + byte 0xed3267e80000000000000002 0xed3267e80000000000000002 + // structure_methods/contract.py:49 + // arc4.emit(ARC4TestStruct(arc4.UInt64(v))) + log + // structure_methods/contract.py:46 + // arc4.emit(ARC4TestStruct(arc4.UInt64(v))) + byte 0xed3267e80000000000000002 0xed3267e80000000000000002 + // structure_methods/contract.py:50 + // arc4.emit(ARC4TestStruct(arc4.UInt64(v))) + log + // structure_methods/contract.py:46 + // arc4.emit(ARC4TestStruct(arc4.UInt64(v))) + byte 0xed3267e80000000000000002 0xed3267e80000000000000002 + // structure_methods/contract.py:51 + // arc4.emit(ARC4TestStruct(arc4.UInt64(v))) + log + // structure_methods/contract.py:46 + // arc4.emit(ARC4TestStruct(arc4.UInt64(v))) + byte 0xed3267e80000000000000002 0xed3267e80000000000000002 + // structure_methods/contract.py:52 + // arc4.emit(ARC4TestStruct(arc4.UInt64(v))) + log + // structure_methods/contract.py:46 + // arc4.emit(ARC4TestStruct(arc4.UInt64(v))) + byte 0xed3267e80000000000000002 0xed3267e80000000000000002 + // structure_methods/contract.py:53 + // arc4.emit(ARC4TestStruct(arc4.UInt64(v))) + log + // structure_methods/contract.py:46 + // arc4.emit(ARC4TestStruct(arc4.UInt64(v))) + byte 0xed3267e80000000000000002 0xed3267e80000000000000002 + log + byte 0xed3267e80000000000000002 0xed3267e80000000000000002 + // structure_methods/contract.py:47 + // arc4.emit(ARC4TestStruct(arc4.UInt64(v))) + log + // structure_methods/contract.py:46 + // arc4.emit(ARC4TestStruct(arc4.UInt64(v))) + byte 0xed3267e80000000000000002 0xed3267e80000000000000002 + // structure_methods/contract.py:48 + // arc4.emit(ARC4TestStruct(arc4.UInt64(v))) + log + // structure_methods/contract.py:46 + // arc4.emit(ARC4TestStruct(arc4.UInt64(v))) + byte 0xed3267e80000000000000002 0xed3267e80000000000000002 + // structure_methods/contract.py:49 + // arc4.emit(ARC4TestStruct(arc4.UInt64(v))) + log + // structure_methods/contract.py:46 + // arc4.emit(ARC4TestStruct(arc4.UInt64(v))) + byte 0xed3267e80000000000000002 0xed3267e80000000000000002 + // structure_methods/contract.py:50 + // arc4.emit(ARC4TestStruct(arc4.UInt64(v))) + log + // structure_methods/contract.py:46 + // arc4.emit(ARC4TestStruct(arc4.UInt64(v))) + byte 0xed3267e80000000000000002 0xed3267e80000000000000002 + // structure_methods/contract.py:51 + // arc4.emit(ARC4TestStruct(arc4.UInt64(v))) + log + // structure_methods/contract.py:46 + // arc4.emit(ARC4TestStruct(arc4.UInt64(v))) + byte 0xed3267e80000000000000002 0xed3267e80000000000000002 + // structure_methods/contract.py:52 + // arc4.emit(ARC4TestStruct(arc4.UInt64(v))) + log + // structure_methods/contract.py:46 + // arc4.emit(ARC4TestStruct(arc4.UInt64(v))) + byte 0xed3267e80000000000000002 0xed3267e80000000000000002 + // structure_methods/contract.py:53 + // arc4.emit(ARC4TestStruct(arc4.UInt64(v))) + log + // structure_methods/contract.py:107 + // GroupedMethods().not_usually_inlined(UInt64(2)) + int 2 2 + callsub not_usually_inlined + // structure_methods/contract.py:108 + // GroupedMethods().not_usually_inlined(UInt64(2)) + int 2 2 + callsub not_usually_inlined + // structure_methods/contract.py:70 + // @public + int 1 1 + return + + diff --git a/test_cases/structure_methods/out/TestContract.ir/TestContract.approval.505.fstack.mir b/test_cases/structure_methods/out/TestContract.ir/TestContract.approval.505.fstack.mir new file mode 100644 index 0000000000..f2b185ca94 --- /dev/null +++ b/test_cases/structure_methods/out/TestContract.ir/TestContract.approval.505.fstack.mir @@ -0,0 +1,223 @@ +// Op Stack (out) +// algopy.arc4.ARC4Contract.approval_program() -> uint64: +subroutine main: + main_block@0: + // structure_methods/contract.py:69 + // class TestContract(ARC4Contract): + txn NumAppArgs tmp%0#1 + bz main___algopy_default_create@5 ; b main_abi_routing@2 + + main_abi_routing@2: + // structure_methods/contract.py:69 + // class TestContract(ARC4Contract): + txna ApplicationArgs 0 tmp%2#0 + method test()void tmp%2#0,Method(test()void) + l-load tmp%2#0 1 Method(test()void),tmp%2#0 + match main_test_route@3 ; b main_switch_case_next@4 + + main_test_route@3: + // structure_methods/contract.py:70 + // @public + txn OnCompletion tmp%3#0 + ! tmp%4#0 + txn ApplicationID tmp%4#0,tmp%5#0 + l-load tmp%4#0 1 tmp%5#0,tmp%4#0 + l-load tmp%5#0 1 tmp%4#0,tmp%5#0 + && tmp%7#0 + assert + callsub test + b main_switch_case_next@4 + + main_switch_case_next@4: + // structure_methods/contract.py:69 + // class TestContract(ARC4Contract): + err + + main___algopy_default_create@5: + txn OnCompletion tmp%8#0 + ! tmp%9#0 + txn ApplicationID tmp%9#0,tmp%10#0 + ! tmp%9#0,tmp%11#0 + l-load tmp%9#0 1 tmp%11#0,tmp%9#0 + l-load tmp%11#0 1 tmp%9#0,tmp%11#0 + && tmp%12#0 + assert + int 1 1 + return + + +// test_cases.structure_methods.contract.GroupedMethods.never_inlined_usually_inlined(v: uint64) -> uint64: +subroutine never_inlined_usually_inlined: + never_inlined_usually_inlined_block@0: (𝕡) v#0 | + // structure_methods/contract.py:42 + // return v + UInt64(1) + p-load v#0 (𝕡) v#0 | v#0 (copy) + int 1 (𝕡) v#0 | v#0 (copy),1 + + (𝕡) v#0 | tmp%0#0 + retsub tmp%0#0 + + +// test_cases.structure_methods.contract.GroupedMethods.not_usually_inlined(v: uint64) -> void: +subroutine not_usually_inlined: + not_usually_inlined_block@0: (𝕡) v#0 | + // structure_methods/contract.py:59 + // arc4.emit(ARC4TestStruct(arc4.UInt64(v))) + p-load v#0 (𝕡) v#0 | v#0 (copy) + itob (𝕡) v#0 | aggregate%val_as_bytes%0#0 + method ARC4TestStruct(uint64) (𝕡) v#0 | aggregate%val_as_bytes%0#0,Method(ARC4TestStruct(uint64)) + l-load aggregate%val_as_bytes%0#0 1 (𝕡) v#0 | Method(ARC4TestStruct(uint64)),aggregate%val_as_bytes%0#0 + concat (𝕡) v#0 | event%0#0 + l-load-copy event%0#0 0 (𝕡) v#0 | event%0#0,event%0#0 (copy) + log (𝕡) v#0 | event%0#0 + // structure_methods/contract.py:60 + // arc4.emit(ARC4TestStruct(arc4.UInt64(v))) + l-load-copy event%0#0 0 (𝕡) v#0 | event%0#0,event%0#0 (copy) + log (𝕡) v#0 | event%0#0 + // structure_methods/contract.py:61 + // arc4.emit(ARC4TestStruct(arc4.UInt64(v))) + l-load-copy event%0#0 0 (𝕡) v#0 | event%0#0,event%0#0 (copy) + log (𝕡) v#0 | event%0#0 + // structure_methods/contract.py:62 + // arc4.emit(ARC4TestStruct(arc4.UInt64(v))) + l-load-copy event%0#0 0 (𝕡) v#0 | event%0#0,event%0#0 (copy) + log (𝕡) v#0 | event%0#0 + // structure_methods/contract.py:63 + // arc4.emit(ARC4TestStruct(arc4.UInt64(v))) + l-load-copy event%0#0 0 (𝕡) v#0 | event%0#0,event%0#0 (copy) + log (𝕡) v#0 | event%0#0 + // structure_methods/contract.py:64 + // arc4.emit(ARC4TestStruct(arc4.UInt64(v))) + l-load-copy event%0#0 0 (𝕡) v#0 | event%0#0,event%0#0 (copy) + log (𝕡) v#0 | event%0#0 + // structure_methods/contract.py:65 + // arc4.emit(ARC4TestStruct(arc4.UInt64(v))) + l-load-copy event%0#0 0 (𝕡) v#0 | event%0#0,event%0#0 (copy) + log (𝕡) v#0 | event%0#0 + // structure_methods/contract.py:66 + // arc4.emit(ARC4TestStruct(arc4.UInt64(v))) + l-load event%0#0 0 (𝕡) v#0 | event%0#0 + log (𝕡) v#0 | + retsub + + +// test_cases.structure_methods.contract.TestContract.test[routing]() -> void: +subroutine test: + test_block@0: + // structure_methods/contract.py:101 + // assert UInt64(3) == GroupedMethods().never_inlined_usually_inlined(UInt64(2)) + int 2 2 + callsub never_inlined_usually_inlined tmp%24#0 + int 3 tmp%24#0,3 + l-load tmp%24#0 1 3,tmp%24#0 + == tmp%25#0 + assert + // structure_methods/contract.py:102 + // assert UInt64(3) == GroupedMethods().never_inlined_usually_inlined(UInt64(2)) + int 2 2 + callsub never_inlined_usually_inlined tmp%26#0 + int 3 tmp%26#0,3 + l-load tmp%26#0 1 3,tmp%26#0 + == tmp%27#0 + assert + // structure_methods/contract.py:46 + // arc4.emit(ARC4TestStruct(arc4.UInt64(v))) + byte 0xed3267e80000000000000002 0xed3267e80000000000000002 + log + byte 0xed3267e80000000000000002 0xed3267e80000000000000002 + // structure_methods/contract.py:47 + // arc4.emit(ARC4TestStruct(arc4.UInt64(v))) + log + // structure_methods/contract.py:46 + // arc4.emit(ARC4TestStruct(arc4.UInt64(v))) + byte 0xed3267e80000000000000002 0xed3267e80000000000000002 + // structure_methods/contract.py:48 + // arc4.emit(ARC4TestStruct(arc4.UInt64(v))) + log + // structure_methods/contract.py:46 + // arc4.emit(ARC4TestStruct(arc4.UInt64(v))) + byte 0xed3267e80000000000000002 0xed3267e80000000000000002 + // structure_methods/contract.py:49 + // arc4.emit(ARC4TestStruct(arc4.UInt64(v))) + log + // structure_methods/contract.py:46 + // arc4.emit(ARC4TestStruct(arc4.UInt64(v))) + byte 0xed3267e80000000000000002 0xed3267e80000000000000002 + // structure_methods/contract.py:50 + // arc4.emit(ARC4TestStruct(arc4.UInt64(v))) + log + // structure_methods/contract.py:46 + // arc4.emit(ARC4TestStruct(arc4.UInt64(v))) + byte 0xed3267e80000000000000002 0xed3267e80000000000000002 + // structure_methods/contract.py:51 + // arc4.emit(ARC4TestStruct(arc4.UInt64(v))) + log + // structure_methods/contract.py:46 + // arc4.emit(ARC4TestStruct(arc4.UInt64(v))) + byte 0xed3267e80000000000000002 0xed3267e80000000000000002 + // structure_methods/contract.py:52 + // arc4.emit(ARC4TestStruct(arc4.UInt64(v))) + log + // structure_methods/contract.py:46 + // arc4.emit(ARC4TestStruct(arc4.UInt64(v))) + byte 0xed3267e80000000000000002 0xed3267e80000000000000002 + // structure_methods/contract.py:53 + // arc4.emit(ARC4TestStruct(arc4.UInt64(v))) + log + // structure_methods/contract.py:46 + // arc4.emit(ARC4TestStruct(arc4.UInt64(v))) + byte 0xed3267e80000000000000002 0xed3267e80000000000000002 + log + byte 0xed3267e80000000000000002 0xed3267e80000000000000002 + // structure_methods/contract.py:47 + // arc4.emit(ARC4TestStruct(arc4.UInt64(v))) + log + // structure_methods/contract.py:46 + // arc4.emit(ARC4TestStruct(arc4.UInt64(v))) + byte 0xed3267e80000000000000002 0xed3267e80000000000000002 + // structure_methods/contract.py:48 + // arc4.emit(ARC4TestStruct(arc4.UInt64(v))) + log + // structure_methods/contract.py:46 + // arc4.emit(ARC4TestStruct(arc4.UInt64(v))) + byte 0xed3267e80000000000000002 0xed3267e80000000000000002 + // structure_methods/contract.py:49 + // arc4.emit(ARC4TestStruct(arc4.UInt64(v))) + log + // structure_methods/contract.py:46 + // arc4.emit(ARC4TestStruct(arc4.UInt64(v))) + byte 0xed3267e80000000000000002 0xed3267e80000000000000002 + // structure_methods/contract.py:50 + // arc4.emit(ARC4TestStruct(arc4.UInt64(v))) + log + // structure_methods/contract.py:46 + // arc4.emit(ARC4TestStruct(arc4.UInt64(v))) + byte 0xed3267e80000000000000002 0xed3267e80000000000000002 + // structure_methods/contract.py:51 + // arc4.emit(ARC4TestStruct(arc4.UInt64(v))) + log + // structure_methods/contract.py:46 + // arc4.emit(ARC4TestStruct(arc4.UInt64(v))) + byte 0xed3267e80000000000000002 0xed3267e80000000000000002 + // structure_methods/contract.py:52 + // arc4.emit(ARC4TestStruct(arc4.UInt64(v))) + log + // structure_methods/contract.py:46 + // arc4.emit(ARC4TestStruct(arc4.UInt64(v))) + byte 0xed3267e80000000000000002 0xed3267e80000000000000002 + // structure_methods/contract.py:53 + // arc4.emit(ARC4TestStruct(arc4.UInt64(v))) + log + // structure_methods/contract.py:107 + // GroupedMethods().not_usually_inlined(UInt64(2)) + int 2 2 + callsub not_usually_inlined + // structure_methods/contract.py:108 + // GroupedMethods().not_usually_inlined(UInt64(2)) + int 2 2 + callsub not_usually_inlined + // structure_methods/contract.py:70 + // @public + int 1 1 + return + + diff --git a/test_cases/structure_methods/out/TestContract.ir/TestContract.approval.506.fstack.opt.mir b/test_cases/structure_methods/out/TestContract.ir/TestContract.approval.506.fstack.opt.mir new file mode 100644 index 0000000000..f2b185ca94 --- /dev/null +++ b/test_cases/structure_methods/out/TestContract.ir/TestContract.approval.506.fstack.opt.mir @@ -0,0 +1,223 @@ +// Op Stack (out) +// algopy.arc4.ARC4Contract.approval_program() -> uint64: +subroutine main: + main_block@0: + // structure_methods/contract.py:69 + // class TestContract(ARC4Contract): + txn NumAppArgs tmp%0#1 + bz main___algopy_default_create@5 ; b main_abi_routing@2 + + main_abi_routing@2: + // structure_methods/contract.py:69 + // class TestContract(ARC4Contract): + txna ApplicationArgs 0 tmp%2#0 + method test()void tmp%2#0,Method(test()void) + l-load tmp%2#0 1 Method(test()void),tmp%2#0 + match main_test_route@3 ; b main_switch_case_next@4 + + main_test_route@3: + // structure_methods/contract.py:70 + // @public + txn OnCompletion tmp%3#0 + ! tmp%4#0 + txn ApplicationID tmp%4#0,tmp%5#0 + l-load tmp%4#0 1 tmp%5#0,tmp%4#0 + l-load tmp%5#0 1 tmp%4#0,tmp%5#0 + && tmp%7#0 + assert + callsub test + b main_switch_case_next@4 + + main_switch_case_next@4: + // structure_methods/contract.py:69 + // class TestContract(ARC4Contract): + err + + main___algopy_default_create@5: + txn OnCompletion tmp%8#0 + ! tmp%9#0 + txn ApplicationID tmp%9#0,tmp%10#0 + ! tmp%9#0,tmp%11#0 + l-load tmp%9#0 1 tmp%11#0,tmp%9#0 + l-load tmp%11#0 1 tmp%9#0,tmp%11#0 + && tmp%12#0 + assert + int 1 1 + return + + +// test_cases.structure_methods.contract.GroupedMethods.never_inlined_usually_inlined(v: uint64) -> uint64: +subroutine never_inlined_usually_inlined: + never_inlined_usually_inlined_block@0: (𝕡) v#0 | + // structure_methods/contract.py:42 + // return v + UInt64(1) + p-load v#0 (𝕡) v#0 | v#0 (copy) + int 1 (𝕡) v#0 | v#0 (copy),1 + + (𝕡) v#0 | tmp%0#0 + retsub tmp%0#0 + + +// test_cases.structure_methods.contract.GroupedMethods.not_usually_inlined(v: uint64) -> void: +subroutine not_usually_inlined: + not_usually_inlined_block@0: (𝕡) v#0 | + // structure_methods/contract.py:59 + // arc4.emit(ARC4TestStruct(arc4.UInt64(v))) + p-load v#0 (𝕡) v#0 | v#0 (copy) + itob (𝕡) v#0 | aggregate%val_as_bytes%0#0 + method ARC4TestStruct(uint64) (𝕡) v#0 | aggregate%val_as_bytes%0#0,Method(ARC4TestStruct(uint64)) + l-load aggregate%val_as_bytes%0#0 1 (𝕡) v#0 | Method(ARC4TestStruct(uint64)),aggregate%val_as_bytes%0#0 + concat (𝕡) v#0 | event%0#0 + l-load-copy event%0#0 0 (𝕡) v#0 | event%0#0,event%0#0 (copy) + log (𝕡) v#0 | event%0#0 + // structure_methods/contract.py:60 + // arc4.emit(ARC4TestStruct(arc4.UInt64(v))) + l-load-copy event%0#0 0 (𝕡) v#0 | event%0#0,event%0#0 (copy) + log (𝕡) v#0 | event%0#0 + // structure_methods/contract.py:61 + // arc4.emit(ARC4TestStruct(arc4.UInt64(v))) + l-load-copy event%0#0 0 (𝕡) v#0 | event%0#0,event%0#0 (copy) + log (𝕡) v#0 | event%0#0 + // structure_methods/contract.py:62 + // arc4.emit(ARC4TestStruct(arc4.UInt64(v))) + l-load-copy event%0#0 0 (𝕡) v#0 | event%0#0,event%0#0 (copy) + log (𝕡) v#0 | event%0#0 + // structure_methods/contract.py:63 + // arc4.emit(ARC4TestStruct(arc4.UInt64(v))) + l-load-copy event%0#0 0 (𝕡) v#0 | event%0#0,event%0#0 (copy) + log (𝕡) v#0 | event%0#0 + // structure_methods/contract.py:64 + // arc4.emit(ARC4TestStruct(arc4.UInt64(v))) + l-load-copy event%0#0 0 (𝕡) v#0 | event%0#0,event%0#0 (copy) + log (𝕡) v#0 | event%0#0 + // structure_methods/contract.py:65 + // arc4.emit(ARC4TestStruct(arc4.UInt64(v))) + l-load-copy event%0#0 0 (𝕡) v#0 | event%0#0,event%0#0 (copy) + log (𝕡) v#0 | event%0#0 + // structure_methods/contract.py:66 + // arc4.emit(ARC4TestStruct(arc4.UInt64(v))) + l-load event%0#0 0 (𝕡) v#0 | event%0#0 + log (𝕡) v#0 | + retsub + + +// test_cases.structure_methods.contract.TestContract.test[routing]() -> void: +subroutine test: + test_block@0: + // structure_methods/contract.py:101 + // assert UInt64(3) == GroupedMethods().never_inlined_usually_inlined(UInt64(2)) + int 2 2 + callsub never_inlined_usually_inlined tmp%24#0 + int 3 tmp%24#0,3 + l-load tmp%24#0 1 3,tmp%24#0 + == tmp%25#0 + assert + // structure_methods/contract.py:102 + // assert UInt64(3) == GroupedMethods().never_inlined_usually_inlined(UInt64(2)) + int 2 2 + callsub never_inlined_usually_inlined tmp%26#0 + int 3 tmp%26#0,3 + l-load tmp%26#0 1 3,tmp%26#0 + == tmp%27#0 + assert + // structure_methods/contract.py:46 + // arc4.emit(ARC4TestStruct(arc4.UInt64(v))) + byte 0xed3267e80000000000000002 0xed3267e80000000000000002 + log + byte 0xed3267e80000000000000002 0xed3267e80000000000000002 + // structure_methods/contract.py:47 + // arc4.emit(ARC4TestStruct(arc4.UInt64(v))) + log + // structure_methods/contract.py:46 + // arc4.emit(ARC4TestStruct(arc4.UInt64(v))) + byte 0xed3267e80000000000000002 0xed3267e80000000000000002 + // structure_methods/contract.py:48 + // arc4.emit(ARC4TestStruct(arc4.UInt64(v))) + log + // structure_methods/contract.py:46 + // arc4.emit(ARC4TestStruct(arc4.UInt64(v))) + byte 0xed3267e80000000000000002 0xed3267e80000000000000002 + // structure_methods/contract.py:49 + // arc4.emit(ARC4TestStruct(arc4.UInt64(v))) + log + // structure_methods/contract.py:46 + // arc4.emit(ARC4TestStruct(arc4.UInt64(v))) + byte 0xed3267e80000000000000002 0xed3267e80000000000000002 + // structure_methods/contract.py:50 + // arc4.emit(ARC4TestStruct(arc4.UInt64(v))) + log + // structure_methods/contract.py:46 + // arc4.emit(ARC4TestStruct(arc4.UInt64(v))) + byte 0xed3267e80000000000000002 0xed3267e80000000000000002 + // structure_methods/contract.py:51 + // arc4.emit(ARC4TestStruct(arc4.UInt64(v))) + log + // structure_methods/contract.py:46 + // arc4.emit(ARC4TestStruct(arc4.UInt64(v))) + byte 0xed3267e80000000000000002 0xed3267e80000000000000002 + // structure_methods/contract.py:52 + // arc4.emit(ARC4TestStruct(arc4.UInt64(v))) + log + // structure_methods/contract.py:46 + // arc4.emit(ARC4TestStruct(arc4.UInt64(v))) + byte 0xed3267e80000000000000002 0xed3267e80000000000000002 + // structure_methods/contract.py:53 + // arc4.emit(ARC4TestStruct(arc4.UInt64(v))) + log + // structure_methods/contract.py:46 + // arc4.emit(ARC4TestStruct(arc4.UInt64(v))) + byte 0xed3267e80000000000000002 0xed3267e80000000000000002 + log + byte 0xed3267e80000000000000002 0xed3267e80000000000000002 + // structure_methods/contract.py:47 + // arc4.emit(ARC4TestStruct(arc4.UInt64(v))) + log + // structure_methods/contract.py:46 + // arc4.emit(ARC4TestStruct(arc4.UInt64(v))) + byte 0xed3267e80000000000000002 0xed3267e80000000000000002 + // structure_methods/contract.py:48 + // arc4.emit(ARC4TestStruct(arc4.UInt64(v))) + log + // structure_methods/contract.py:46 + // arc4.emit(ARC4TestStruct(arc4.UInt64(v))) + byte 0xed3267e80000000000000002 0xed3267e80000000000000002 + // structure_methods/contract.py:49 + // arc4.emit(ARC4TestStruct(arc4.UInt64(v))) + log + // structure_methods/contract.py:46 + // arc4.emit(ARC4TestStruct(arc4.UInt64(v))) + byte 0xed3267e80000000000000002 0xed3267e80000000000000002 + // structure_methods/contract.py:50 + // arc4.emit(ARC4TestStruct(arc4.UInt64(v))) + log + // structure_methods/contract.py:46 + // arc4.emit(ARC4TestStruct(arc4.UInt64(v))) + byte 0xed3267e80000000000000002 0xed3267e80000000000000002 + // structure_methods/contract.py:51 + // arc4.emit(ARC4TestStruct(arc4.UInt64(v))) + log + // structure_methods/contract.py:46 + // arc4.emit(ARC4TestStruct(arc4.UInt64(v))) + byte 0xed3267e80000000000000002 0xed3267e80000000000000002 + // structure_methods/contract.py:52 + // arc4.emit(ARC4TestStruct(arc4.UInt64(v))) + log + // structure_methods/contract.py:46 + // arc4.emit(ARC4TestStruct(arc4.UInt64(v))) + byte 0xed3267e80000000000000002 0xed3267e80000000000000002 + // structure_methods/contract.py:53 + // arc4.emit(ARC4TestStruct(arc4.UInt64(v))) + log + // structure_methods/contract.py:107 + // GroupedMethods().not_usually_inlined(UInt64(2)) + int 2 2 + callsub not_usually_inlined + // structure_methods/contract.py:108 + // GroupedMethods().not_usually_inlined(UInt64(2)) + int 2 2 + callsub not_usually_inlined + // structure_methods/contract.py:70 + // @public + int 1 1 + return + + diff --git a/test_cases/structure_methods/out/TestContract.ir/TestContract.approval.507.mir b/test_cases/structure_methods/out/TestContract.ir/TestContract.approval.507.mir new file mode 100644 index 0000000000..f2b185ca94 --- /dev/null +++ b/test_cases/structure_methods/out/TestContract.ir/TestContract.approval.507.mir @@ -0,0 +1,223 @@ +// Op Stack (out) +// algopy.arc4.ARC4Contract.approval_program() -> uint64: +subroutine main: + main_block@0: + // structure_methods/contract.py:69 + // class TestContract(ARC4Contract): + txn NumAppArgs tmp%0#1 + bz main___algopy_default_create@5 ; b main_abi_routing@2 + + main_abi_routing@2: + // structure_methods/contract.py:69 + // class TestContract(ARC4Contract): + txna ApplicationArgs 0 tmp%2#0 + method test()void tmp%2#0,Method(test()void) + l-load tmp%2#0 1 Method(test()void),tmp%2#0 + match main_test_route@3 ; b main_switch_case_next@4 + + main_test_route@3: + // structure_methods/contract.py:70 + // @public + txn OnCompletion tmp%3#0 + ! tmp%4#0 + txn ApplicationID tmp%4#0,tmp%5#0 + l-load tmp%4#0 1 tmp%5#0,tmp%4#0 + l-load tmp%5#0 1 tmp%4#0,tmp%5#0 + && tmp%7#0 + assert + callsub test + b main_switch_case_next@4 + + main_switch_case_next@4: + // structure_methods/contract.py:69 + // class TestContract(ARC4Contract): + err + + main___algopy_default_create@5: + txn OnCompletion tmp%8#0 + ! tmp%9#0 + txn ApplicationID tmp%9#0,tmp%10#0 + ! tmp%9#0,tmp%11#0 + l-load tmp%9#0 1 tmp%11#0,tmp%9#0 + l-load tmp%11#0 1 tmp%9#0,tmp%11#0 + && tmp%12#0 + assert + int 1 1 + return + + +// test_cases.structure_methods.contract.GroupedMethods.never_inlined_usually_inlined(v: uint64) -> uint64: +subroutine never_inlined_usually_inlined: + never_inlined_usually_inlined_block@0: (𝕡) v#0 | + // structure_methods/contract.py:42 + // return v + UInt64(1) + p-load v#0 (𝕡) v#0 | v#0 (copy) + int 1 (𝕡) v#0 | v#0 (copy),1 + + (𝕡) v#0 | tmp%0#0 + retsub tmp%0#0 + + +// test_cases.structure_methods.contract.GroupedMethods.not_usually_inlined(v: uint64) -> void: +subroutine not_usually_inlined: + not_usually_inlined_block@0: (𝕡) v#0 | + // structure_methods/contract.py:59 + // arc4.emit(ARC4TestStruct(arc4.UInt64(v))) + p-load v#0 (𝕡) v#0 | v#0 (copy) + itob (𝕡) v#0 | aggregate%val_as_bytes%0#0 + method ARC4TestStruct(uint64) (𝕡) v#0 | aggregate%val_as_bytes%0#0,Method(ARC4TestStruct(uint64)) + l-load aggregate%val_as_bytes%0#0 1 (𝕡) v#0 | Method(ARC4TestStruct(uint64)),aggregate%val_as_bytes%0#0 + concat (𝕡) v#0 | event%0#0 + l-load-copy event%0#0 0 (𝕡) v#0 | event%0#0,event%0#0 (copy) + log (𝕡) v#0 | event%0#0 + // structure_methods/contract.py:60 + // arc4.emit(ARC4TestStruct(arc4.UInt64(v))) + l-load-copy event%0#0 0 (𝕡) v#0 | event%0#0,event%0#0 (copy) + log (𝕡) v#0 | event%0#0 + // structure_methods/contract.py:61 + // arc4.emit(ARC4TestStruct(arc4.UInt64(v))) + l-load-copy event%0#0 0 (𝕡) v#0 | event%0#0,event%0#0 (copy) + log (𝕡) v#0 | event%0#0 + // structure_methods/contract.py:62 + // arc4.emit(ARC4TestStruct(arc4.UInt64(v))) + l-load-copy event%0#0 0 (𝕡) v#0 | event%0#0,event%0#0 (copy) + log (𝕡) v#0 | event%0#0 + // structure_methods/contract.py:63 + // arc4.emit(ARC4TestStruct(arc4.UInt64(v))) + l-load-copy event%0#0 0 (𝕡) v#0 | event%0#0,event%0#0 (copy) + log (𝕡) v#0 | event%0#0 + // structure_methods/contract.py:64 + // arc4.emit(ARC4TestStruct(arc4.UInt64(v))) + l-load-copy event%0#0 0 (𝕡) v#0 | event%0#0,event%0#0 (copy) + log (𝕡) v#0 | event%0#0 + // structure_methods/contract.py:65 + // arc4.emit(ARC4TestStruct(arc4.UInt64(v))) + l-load-copy event%0#0 0 (𝕡) v#0 | event%0#0,event%0#0 (copy) + log (𝕡) v#0 | event%0#0 + // structure_methods/contract.py:66 + // arc4.emit(ARC4TestStruct(arc4.UInt64(v))) + l-load event%0#0 0 (𝕡) v#0 | event%0#0 + log (𝕡) v#0 | + retsub + + +// test_cases.structure_methods.contract.TestContract.test[routing]() -> void: +subroutine test: + test_block@0: + // structure_methods/contract.py:101 + // assert UInt64(3) == GroupedMethods().never_inlined_usually_inlined(UInt64(2)) + int 2 2 + callsub never_inlined_usually_inlined tmp%24#0 + int 3 tmp%24#0,3 + l-load tmp%24#0 1 3,tmp%24#0 + == tmp%25#0 + assert + // structure_methods/contract.py:102 + // assert UInt64(3) == GroupedMethods().never_inlined_usually_inlined(UInt64(2)) + int 2 2 + callsub never_inlined_usually_inlined tmp%26#0 + int 3 tmp%26#0,3 + l-load tmp%26#0 1 3,tmp%26#0 + == tmp%27#0 + assert + // structure_methods/contract.py:46 + // arc4.emit(ARC4TestStruct(arc4.UInt64(v))) + byte 0xed3267e80000000000000002 0xed3267e80000000000000002 + log + byte 0xed3267e80000000000000002 0xed3267e80000000000000002 + // structure_methods/contract.py:47 + // arc4.emit(ARC4TestStruct(arc4.UInt64(v))) + log + // structure_methods/contract.py:46 + // arc4.emit(ARC4TestStruct(arc4.UInt64(v))) + byte 0xed3267e80000000000000002 0xed3267e80000000000000002 + // structure_methods/contract.py:48 + // arc4.emit(ARC4TestStruct(arc4.UInt64(v))) + log + // structure_methods/contract.py:46 + // arc4.emit(ARC4TestStruct(arc4.UInt64(v))) + byte 0xed3267e80000000000000002 0xed3267e80000000000000002 + // structure_methods/contract.py:49 + // arc4.emit(ARC4TestStruct(arc4.UInt64(v))) + log + // structure_methods/contract.py:46 + // arc4.emit(ARC4TestStruct(arc4.UInt64(v))) + byte 0xed3267e80000000000000002 0xed3267e80000000000000002 + // structure_methods/contract.py:50 + // arc4.emit(ARC4TestStruct(arc4.UInt64(v))) + log + // structure_methods/contract.py:46 + // arc4.emit(ARC4TestStruct(arc4.UInt64(v))) + byte 0xed3267e80000000000000002 0xed3267e80000000000000002 + // structure_methods/contract.py:51 + // arc4.emit(ARC4TestStruct(arc4.UInt64(v))) + log + // structure_methods/contract.py:46 + // arc4.emit(ARC4TestStruct(arc4.UInt64(v))) + byte 0xed3267e80000000000000002 0xed3267e80000000000000002 + // structure_methods/contract.py:52 + // arc4.emit(ARC4TestStruct(arc4.UInt64(v))) + log + // structure_methods/contract.py:46 + // arc4.emit(ARC4TestStruct(arc4.UInt64(v))) + byte 0xed3267e80000000000000002 0xed3267e80000000000000002 + // structure_methods/contract.py:53 + // arc4.emit(ARC4TestStruct(arc4.UInt64(v))) + log + // structure_methods/contract.py:46 + // arc4.emit(ARC4TestStruct(arc4.UInt64(v))) + byte 0xed3267e80000000000000002 0xed3267e80000000000000002 + log + byte 0xed3267e80000000000000002 0xed3267e80000000000000002 + // structure_methods/contract.py:47 + // arc4.emit(ARC4TestStruct(arc4.UInt64(v))) + log + // structure_methods/contract.py:46 + // arc4.emit(ARC4TestStruct(arc4.UInt64(v))) + byte 0xed3267e80000000000000002 0xed3267e80000000000000002 + // structure_methods/contract.py:48 + // arc4.emit(ARC4TestStruct(arc4.UInt64(v))) + log + // structure_methods/contract.py:46 + // arc4.emit(ARC4TestStruct(arc4.UInt64(v))) + byte 0xed3267e80000000000000002 0xed3267e80000000000000002 + // structure_methods/contract.py:49 + // arc4.emit(ARC4TestStruct(arc4.UInt64(v))) + log + // structure_methods/contract.py:46 + // arc4.emit(ARC4TestStruct(arc4.UInt64(v))) + byte 0xed3267e80000000000000002 0xed3267e80000000000000002 + // structure_methods/contract.py:50 + // arc4.emit(ARC4TestStruct(arc4.UInt64(v))) + log + // structure_methods/contract.py:46 + // arc4.emit(ARC4TestStruct(arc4.UInt64(v))) + byte 0xed3267e80000000000000002 0xed3267e80000000000000002 + // structure_methods/contract.py:51 + // arc4.emit(ARC4TestStruct(arc4.UInt64(v))) + log + // structure_methods/contract.py:46 + // arc4.emit(ARC4TestStruct(arc4.UInt64(v))) + byte 0xed3267e80000000000000002 0xed3267e80000000000000002 + // structure_methods/contract.py:52 + // arc4.emit(ARC4TestStruct(arc4.UInt64(v))) + log + // structure_methods/contract.py:46 + // arc4.emit(ARC4TestStruct(arc4.UInt64(v))) + byte 0xed3267e80000000000000002 0xed3267e80000000000000002 + // structure_methods/contract.py:53 + // arc4.emit(ARC4TestStruct(arc4.UInt64(v))) + log + // structure_methods/contract.py:107 + // GroupedMethods().not_usually_inlined(UInt64(2)) + int 2 2 + callsub not_usually_inlined + // structure_methods/contract.py:108 + // GroupedMethods().not_usually_inlined(UInt64(2)) + int 2 2 + callsub not_usually_inlined + // structure_methods/contract.py:70 + // @public + int 1 1 + return + + diff --git a/test_cases/structure_methods/out/TestContract.ir/TestContract.clear.000.ssa.ir b/test_cases/structure_methods/out/TestContract.ir/TestContract.clear.000.ssa.ir new file mode 100644 index 0000000000..b19ab730e7 --- /dev/null +++ b/test_cases/structure_methods/out/TestContract.ir/TestContract.clear.000.ssa.ir @@ -0,0 +1,3 @@ +main algopy.arc4.ARC4Contract.clear_state_program: + block@0: // L1 + return 1u \ No newline at end of file diff --git a/test_cases/structure_methods/out/TestContract.ir/TestContract.clear.100.ssa.array.ir b/test_cases/structure_methods/out/TestContract.ir/TestContract.clear.100.ssa.array.ir new file mode 100644 index 0000000000..b19ab730e7 --- /dev/null +++ b/test_cases/structure_methods/out/TestContract.ir/TestContract.clear.100.ssa.array.ir @@ -0,0 +1,3 @@ +main algopy.arc4.ARC4Contract.clear_state_program: + block@0: // L1 + return 1u \ No newline at end of file diff --git a/test_cases/structure_methods/out/TestContract.ir/TestContract.clear.300.ssa.slot.ir b/test_cases/structure_methods/out/TestContract.ir/TestContract.clear.300.ssa.slot.ir new file mode 100644 index 0000000000..b19ab730e7 --- /dev/null +++ b/test_cases/structure_methods/out/TestContract.ir/TestContract.clear.300.ssa.slot.ir @@ -0,0 +1,3 @@ +main algopy.arc4.ARC4Contract.clear_state_program: + block@0: // L1 + return 1u \ No newline at end of file diff --git a/test_cases/structure_methods/out/TestContract.ir/TestContract.clear.400.destructured.ir b/test_cases/structure_methods/out/TestContract.ir/TestContract.clear.400.destructured.ir new file mode 100644 index 0000000000..b19ab730e7 --- /dev/null +++ b/test_cases/structure_methods/out/TestContract.ir/TestContract.clear.400.destructured.ir @@ -0,0 +1,3 @@ +main algopy.arc4.ARC4Contract.clear_state_program: + block@0: // L1 + return 1u \ No newline at end of file diff --git a/test_cases/structure_methods/out/TestContract.ir/TestContract.clear.500.build.mir b/test_cases/structure_methods/out/TestContract.ir/TestContract.clear.500.build.mir new file mode 100644 index 0000000000..5efa4789fa --- /dev/null +++ b/test_cases/structure_methods/out/TestContract.ir/TestContract.clear.500.build.mir @@ -0,0 +1,8 @@ +// Op Stack (out) +// algopy.arc4.ARC4Contract.clear_state_program() -> uint64: +subroutine main: + main_block@0: + int 1 1 + return + + diff --git a/test_cases/structure_methods/out/TestContract.ir/TestContract.clear.501.lstack.mir b/test_cases/structure_methods/out/TestContract.ir/TestContract.clear.501.lstack.mir new file mode 100644 index 0000000000..5efa4789fa --- /dev/null +++ b/test_cases/structure_methods/out/TestContract.ir/TestContract.clear.501.lstack.mir @@ -0,0 +1,8 @@ +// Op Stack (out) +// algopy.arc4.ARC4Contract.clear_state_program() -> uint64: +subroutine main: + main_block@0: + int 1 1 + return + + diff --git a/test_cases/structure_methods/out/TestContract.ir/TestContract.clear.502.lstack.opt.mir b/test_cases/structure_methods/out/TestContract.ir/TestContract.clear.502.lstack.opt.mir new file mode 100644 index 0000000000..5efa4789fa --- /dev/null +++ b/test_cases/structure_methods/out/TestContract.ir/TestContract.clear.502.lstack.opt.mir @@ -0,0 +1,8 @@ +// Op Stack (out) +// algopy.arc4.ARC4Contract.clear_state_program() -> uint64: +subroutine main: + main_block@0: + int 1 1 + return + + diff --git a/test_cases/structure_methods/out/TestContract.ir/TestContract.clear.503.xstack.mir b/test_cases/structure_methods/out/TestContract.ir/TestContract.clear.503.xstack.mir new file mode 100644 index 0000000000..5efa4789fa --- /dev/null +++ b/test_cases/structure_methods/out/TestContract.ir/TestContract.clear.503.xstack.mir @@ -0,0 +1,8 @@ +// Op Stack (out) +// algopy.arc4.ARC4Contract.clear_state_program() -> uint64: +subroutine main: + main_block@0: + int 1 1 + return + + diff --git a/test_cases/structure_methods/out/TestContract.ir/TestContract.clear.504.xstack.opt.mir b/test_cases/structure_methods/out/TestContract.ir/TestContract.clear.504.xstack.opt.mir new file mode 100644 index 0000000000..5efa4789fa --- /dev/null +++ b/test_cases/structure_methods/out/TestContract.ir/TestContract.clear.504.xstack.opt.mir @@ -0,0 +1,8 @@ +// Op Stack (out) +// algopy.arc4.ARC4Contract.clear_state_program() -> uint64: +subroutine main: + main_block@0: + int 1 1 + return + + diff --git a/test_cases/structure_methods/out/TestContract.ir/TestContract.clear.505.fstack.mir b/test_cases/structure_methods/out/TestContract.ir/TestContract.clear.505.fstack.mir new file mode 100644 index 0000000000..5efa4789fa --- /dev/null +++ b/test_cases/structure_methods/out/TestContract.ir/TestContract.clear.505.fstack.mir @@ -0,0 +1,8 @@ +// Op Stack (out) +// algopy.arc4.ARC4Contract.clear_state_program() -> uint64: +subroutine main: + main_block@0: + int 1 1 + return + + diff --git a/test_cases/structure_methods/out/TestContract.ir/TestContract.clear.506.fstack.opt.mir b/test_cases/structure_methods/out/TestContract.ir/TestContract.clear.506.fstack.opt.mir new file mode 100644 index 0000000000..5efa4789fa --- /dev/null +++ b/test_cases/structure_methods/out/TestContract.ir/TestContract.clear.506.fstack.opt.mir @@ -0,0 +1,8 @@ +// Op Stack (out) +// algopy.arc4.ARC4Contract.clear_state_program() -> uint64: +subroutine main: + main_block@0: + int 1 1 + return + + diff --git a/test_cases/structure_methods/out/TestContract.ir/TestContract.clear.507.mir b/test_cases/structure_methods/out/TestContract.ir/TestContract.clear.507.mir new file mode 100644 index 0000000000..5efa4789fa --- /dev/null +++ b/test_cases/structure_methods/out/TestContract.ir/TestContract.clear.507.mir @@ -0,0 +1,8 @@ +// Op Stack (out) +// algopy.arc4.ARC4Contract.clear_state_program() -> uint64: +subroutine main: + main_block@0: + int 1 1 + return + + diff --git a/test_cases/structure_methods/out/client_TestContract.py b/test_cases/structure_methods/out/client_TestContract.py new file mode 100644 index 0000000000..a4eb8c8a13 --- /dev/null +++ b/test_cases/structure_methods/out/client_TestContract.py @@ -0,0 +1,13 @@ +# This file is auto-generated, do not modify +# flake8: noqa +# fmt: off +import typing + +import algopy + + +class TestContract(algopy.arc4.ARC4Client, typing.Protocol): + @algopy.arc4.abimethod + def test( + self, + ) -> None: ... diff --git a/test_cases/structure_methods/out/module.awst b/test_cases/structure_methods/out/module.awst new file mode 100644 index 0000000000..fe746484ba --- /dev/null +++ b/test_cases/structure_methods/out/module.awst @@ -0,0 +1,113 @@ +subroutine return_value_times(self: test_cases.structure_methods.contract.ARC4TestStruct, times: uint64): uint64 +{ + return arc4_decode(self.value, uint64) * times +} + +subroutine return1(): uint64 +{ + return 1u +} + +subroutine return_value_times(self: test_cases.structure_methods.contract.TestStruct, times: uint64): uint64 +{ + return self.value * times +} + +subroutine return1(): uint64 +{ + return 1u +} + +subroutine return_value_times(self: test_cases.structure_methods.contract.TestNamedTuple, times: uint64): uint64 +{ + return self.value * times +} + +subroutine return1(): uint64 +{ + return 1u +} + +subroutine never_inlined_usually_inlined(self: test_cases.structure_methods.contract.GroupedMethods, v: uint64): uint64 +{ + return v + 1u +} + +subroutine always_inlined_not_usually_inlined(self: test_cases.structure_methods.contract.GroupedMethods, v: uint64): void +{ + emit('ARC4TestStruct(uint64)', new test_cases.structure_methods.contract.ARC4TestStruct(value=arc4_encode(v, arc4.uint64))) + emit('ARC4TestStruct(uint64)', new test_cases.structure_methods.contract.ARC4TestStruct(value=arc4_encode(v, arc4.uint64))) + emit('ARC4TestStruct(uint64)', new test_cases.structure_methods.contract.ARC4TestStruct(value=arc4_encode(v, arc4.uint64))) + emit('ARC4TestStruct(uint64)', new test_cases.structure_methods.contract.ARC4TestStruct(value=arc4_encode(v, arc4.uint64))) + emit('ARC4TestStruct(uint64)', new test_cases.structure_methods.contract.ARC4TestStruct(value=arc4_encode(v, arc4.uint64))) + emit('ARC4TestStruct(uint64)', new test_cases.structure_methods.contract.ARC4TestStruct(value=arc4_encode(v, arc4.uint64))) + emit('ARC4TestStruct(uint64)', new test_cases.structure_methods.contract.ARC4TestStruct(value=arc4_encode(v, arc4.uint64))) + emit('ARC4TestStruct(uint64)', new test_cases.structure_methods.contract.ARC4TestStruct(value=arc4_encode(v, arc4.uint64))) +} + +subroutine usually_inlined(self: test_cases.structure_methods.contract.GroupedMethods, v: uint64): uint64 +{ + return v + 1u +} + +subroutine not_usually_inlined(self: test_cases.structure_methods.contract.GroupedMethods, v: uint64): void +{ + emit('ARC4TestStruct(uint64)', new test_cases.structure_methods.contract.ARC4TestStruct(value=arc4_encode(v, arc4.uint64))) + emit('ARC4TestStruct(uint64)', new test_cases.structure_methods.contract.ARC4TestStruct(value=arc4_encode(v, arc4.uint64))) + emit('ARC4TestStruct(uint64)', new test_cases.structure_methods.contract.ARC4TestStruct(value=arc4_encode(v, arc4.uint64))) + emit('ARC4TestStruct(uint64)', new test_cases.structure_methods.contract.ARC4TestStruct(value=arc4_encode(v, arc4.uint64))) + emit('ARC4TestStruct(uint64)', new test_cases.structure_methods.contract.ARC4TestStruct(value=arc4_encode(v, arc4.uint64))) + emit('ARC4TestStruct(uint64)', new test_cases.structure_methods.contract.ARC4TestStruct(value=arc4_encode(v, arc4.uint64))) + emit('ARC4TestStruct(uint64)', new test_cases.structure_methods.contract.ARC4TestStruct(value=arc4_encode(v, arc4.uint64))) + emit('ARC4TestStruct(uint64)', new test_cases.structure_methods.contract.ARC4TestStruct(value=arc4_encode(v, arc4.uint64))) +} + +contract TestContract +{ + method_resolution_order: ( + algopy.arc4.ARC4Contract, + algopy._contract.Contract, + ) + + subroutine algopy.arc4.ARC4Contract.approval_program(): bool + { + return arc4_router() + } + + subroutine algopy.arc4.ARC4Contract.clear_state_program(): bool + { + return true + } + + abimethod test_cases.structure_methods.contract.TestContract.test(): void + { + assert(18u == test_cases.structure_methods.contract.ARC4TestStruct.return_value_times(new test_cases.structure_methods.contract.ARC4TestStruct(value=9_arc4u64), 2u)) + assert(18u == test_cases.structure_methods.contract.TestStruct.return_value_times(new test_cases.structure_methods.contract.TestStruct(value=9u), 2u)) + assert(18u == test_cases.structure_methods.contract.TestNamedTuple.return_value_times((value=9u), 2u)) + assert(18u == test_cases.structure_methods.contract.ARC4TestStruct.return_value_times(new test_cases.structure_methods.contract.ARC4TestStruct(value=9_arc4u64), 2u)) + assert(18u == test_cases.structure_methods.contract.TestStruct.return_value_times(new test_cases.structure_methods.contract.TestStruct(value=9u), 2u)) + assert(18u == test_cases.structure_methods.contract.TestNamedTuple.return_value_times((value=9u), 2u)) + assert(1u == test_cases.structure_methods.contract.ARC4TestStruct.return1()) + assert(1u == test_cases.structure_methods.contract.TestStruct.return1()) + assert(1u == test_cases.structure_methods.contract.TestNamedTuple.return1()) + assert(1u == test_cases.structure_methods.contract.ARC4TestStruct.return1()) + assert(1u == test_cases.structure_methods.contract.TestStruct.return1()) + assert(1u == test_cases.structure_methods.contract.TestNamedTuple.return1()) + assert(3u == test_cases.structure_methods.contract.GroupedMethods.never_inlined_usually_inlined((), 2u)) + assert(3u == test_cases.structure_methods.contract.GroupedMethods.never_inlined_usually_inlined((), 2u)) + assert(3u == test_cases.structure_methods.contract.GroupedMethods.usually_inlined((), 2u)) + assert(3u == test_cases.structure_methods.contract.GroupedMethods.usually_inlined((), 2u)) + test_cases.structure_methods.contract.GroupedMethods.always_inlined_not_usually_inlined((), 2u) + test_cases.structure_methods.contract.GroupedMethods.always_inlined_not_usually_inlined((), 2u) + test_cases.structure_methods.contract.GroupedMethods.not_usually_inlined((), 2u) + test_cases.structure_methods.contract.GroupedMethods.not_usually_inlined((), 2u) + } + + baremethod test_cases.structure_methods.contract.TestContract.__algopy_default_create(): void + { + } + + subroutine algopy._contract.Contract.__init__(): void + { + } +} \ No newline at end of file diff --git a/test_cases/structure_methods/out_O2/TestContract.approval.puya.map b/test_cases/structure_methods/out_O2/TestContract.approval.puya.map new file mode 100644 index 0000000000..b7232f88b8 --- /dev/null +++ b/test_cases/structure_methods/out_O2/TestContract.approval.puya.map @@ -0,0 +1,9 @@ +{ + "version": 3, + "sources": [ + "../contract.py" + ], + "mappings": ";;;;;;;;;;;;;;;;;;;;;AAoEA;;AAAA;;;AAAA;;;;;;AAAA;;;AAAA;;;;AAAA;AACK;;AAAA;AAAA;;AAAA;AAAA;AA+BsE;AAA/C;;;AAAb;AAAA;AAAP;AACmE;AAA/C;;;AAAb;AAAA;AAAP;AAxDA;AAAA;AAAA;AACA;AADA;AAEA;AAFA;AAGA;AAHA;AAIA;AAJA;AAKA;AALA;AAMA;AANA;AAOA;AAPA;AAAA;AAAA;AACA;AADA;AAEA;AAFA;AAGA;AAHA;AAIA;AAJA;AAKA;AALA;AAMA;AANA;AAOA;AAsDqC;AAArC;;;AACqC;AAArC;;;AAtCH;AAAA;;;;;;;;;AA9BA;;;AAEU;;AAAI;AAAJ;AAAP;AAgBJ;;;AAC6B;;AAAA;AAAzB;;;;;;AAAA;AAAA;AAAA;AAAA;AACA;AAAA;AACA;AAAA;AACA;AAAA;AACA;AAAA;AACA;AAAA;AACA;AAAA;AACA;", + "op_pc_offset": 0, + "pc_events": {} +} \ No newline at end of file diff --git a/test_cases/structure_methods/out_O2/TestContract.approval.stats.txt b/test_cases/structure_methods/out_O2/TestContract.approval.stats.txt new file mode 100644 index 0000000000..df86509228 --- /dev/null +++ b/test_cases/structure_methods/out_O2/TestContract.approval.stats.txt @@ -0,0 +1,10 @@ +total_bytes = 149 +total_ops = 94 +constant_bytes = 56 +constant_ops = 28 +control_flow_bytes = 19 +control_flow_ops = 6 +stack_bytes = 12 +stack_ops = 10 +other_bytes = 61 +other_ops = 50 \ No newline at end of file diff --git a/test_cases/structure_methods/out_O2/TestContract.approval.teal b/test_cases/structure_methods/out_O2/TestContract.approval.teal new file mode 100644 index 0000000000..1770c40f1d --- /dev/null +++ b/test_cases/structure_methods/out_O2/TestContract.approval.teal @@ -0,0 +1,111 @@ +#pragma version 11 +#pragma typetrack false + +// algopy.arc4.ARC4Contract.approval_program() -> uint64: +main: + intcblock 2 3 1 + bytecblock 0xed3267e80000000000000002 + txn NumAppArgs + bz main___algopy_default_create@5 + pushbytes 0xa78000de // method "test()void" + txna ApplicationArgs 0 + match main_test_route@3 + err + +main_test_route@3: + txn OnCompletion + ! + txn ApplicationID + && + assert + intc_0 // 2 + callsub never_inlined_usually_inlined + intc_1 // 3 + == + assert + intc_0 // 2 + callsub never_inlined_usually_inlined + intc_1 // 3 + == + assert + bytec_0 // 0xed3267e80000000000000002 + log + bytec_0 // 0xed3267e80000000000000002 + log + bytec_0 // 0xed3267e80000000000000002 + log + bytec_0 // 0xed3267e80000000000000002 + log + bytec_0 // 0xed3267e80000000000000002 + log + bytec_0 // 0xed3267e80000000000000002 + log + bytec_0 // 0xed3267e80000000000000002 + log + bytec_0 // 0xed3267e80000000000000002 + log + bytec_0 // 0xed3267e80000000000000002 + log + bytec_0 // 0xed3267e80000000000000002 + log + bytec_0 // 0xed3267e80000000000000002 + log + bytec_0 // 0xed3267e80000000000000002 + log + bytec_0 // 0xed3267e80000000000000002 + log + bytec_0 // 0xed3267e80000000000000002 + log + bytec_0 // 0xed3267e80000000000000002 + log + bytec_0 // 0xed3267e80000000000000002 + log + intc_0 // 2 + callsub not_usually_inlined + intc_0 // 2 + callsub not_usually_inlined + intc_2 // 1 + return + +main___algopy_default_create@5: + txn OnCompletion + ! + txn ApplicationID + ! + && + return + + +// test_cases.structure_methods.contract.GroupedMethods.never_inlined_usually_inlined(v: uint64) -> uint64: +never_inlined_usually_inlined: + proto 1 1 + frame_dig -1 + intc_2 // 1 + + + retsub + + +// test_cases.structure_methods.contract.GroupedMethods.not_usually_inlined(v: uint64) -> void: +not_usually_inlined: + proto 1 0 + frame_dig -1 + itob + pushbytes 0xed3267e8 // method "ARC4TestStruct(uint64)" + swap + concat + dup + log + dup + log + dup + log + dup + log + dup + log + dup + log + dup + log + log + retsub diff --git a/test_cases/structure_methods/out_O2/TestContract.clear.puya.map b/test_cases/structure_methods/out_O2/TestContract.clear.puya.map new file mode 100644 index 0000000000..5ef79ffab9 --- /dev/null +++ b/test_cases/structure_methods/out_O2/TestContract.clear.puya.map @@ -0,0 +1,7 @@ +{ + "version": 3, + "sources": [], + "mappings": ";;;", + "op_pc_offset": 0, + "pc_events": {} +} \ No newline at end of file diff --git a/test_cases/structure_methods/out_O2/TestContract.clear.stats.txt b/test_cases/structure_methods/out_O2/TestContract.clear.stats.txt new file mode 100644 index 0000000000..08e983c105 --- /dev/null +++ b/test_cases/structure_methods/out_O2/TestContract.clear.stats.txt @@ -0,0 +1,10 @@ +total_bytes = 4 +total_ops = 2 +constant_bytes = 2 +constant_ops = 1 +control_flow_bytes = 0 +control_flow_ops = 0 +stack_bytes = 0 +stack_ops = 0 +other_bytes = 1 +other_ops = 1 \ No newline at end of file diff --git a/test_cases/structure_methods/out_O2/TestContract.clear.teal b/test_cases/structure_methods/out_O2/TestContract.clear.teal new file mode 100644 index 0000000000..75f539be65 --- /dev/null +++ b/test_cases/structure_methods/out_O2/TestContract.clear.teal @@ -0,0 +1,7 @@ +#pragma version 11 +#pragma typetrack false + +// algopy.arc4.ARC4Contract.clear_state_program() -> uint64: +main: + pushint 1 + return diff --git a/test_cases/structure_methods/out_O2/TestContract.ir/TestContract.approval.400.destructured.ir b/test_cases/structure_methods/out_O2/TestContract.ir/TestContract.approval.400.destructured.ir new file mode 100644 index 0000000000..95b24e3b35 --- /dev/null +++ b/test_cases/structure_methods/out_O2/TestContract.ir/TestContract.approval.400.destructured.ir @@ -0,0 +1,67 @@ +main algopy.arc4.ARC4Contract.approval_program: + block@0: // L1 + let tmp%0#1: uint64 = (txn NumAppArgs) + goto tmp%0#1 ? block@2 : block@5 + block@2: // abi_routing_L69 + let tmp%2#0: bytes = (txna ApplicationArgs 0) + switch tmp%2#0 {method "test()void" => block@3, * => block@4} + block@3: // test_route_L70 + let tmp%3#0: uint64 = (txn OnCompletion) + let tmp%4#0: bool = (! tmp%3#0) + let tmp%5#0: uint64 = (txn ApplicationID) + let tmp%7#0: bool = (&& tmp%4#0 tmp%5#0) + (assert tmp%7#0) + let tmp%24#0: uint64 = test_cases.structure_methods.contract.GroupedMethods.never_inlined_usually_inlined(2u) + let tmp%25#0: bool = (== 3u tmp%24#0) + (assert tmp%25#0) + let tmp%26#0: uint64 = test_cases.structure_methods.contract.GroupedMethods.never_inlined_usually_inlined(2u) + let tmp%27#0: bool = (== 3u tmp%26#0) + (assert tmp%27#0) + (log 0xed3267e80000000000000002) + (log 0xed3267e80000000000000002) + (log 0xed3267e80000000000000002) + (log 0xed3267e80000000000000002) + (log 0xed3267e80000000000000002) + (log 0xed3267e80000000000000002) + (log 0xed3267e80000000000000002) + (log 0xed3267e80000000000000002) + (log 0xed3267e80000000000000002) + (log 0xed3267e80000000000000002) + (log 0xed3267e80000000000000002) + (log 0xed3267e80000000000000002) + (log 0xed3267e80000000000000002) + (log 0xed3267e80000000000000002) + (log 0xed3267e80000000000000002) + (log 0xed3267e80000000000000002) + test_cases.structure_methods.contract.GroupedMethods.not_usually_inlined(2u) + test_cases.structure_methods.contract.GroupedMethods.not_usually_inlined(2u) + exit 1u + block@4: // switch_case_next_L69 + fail + block@5: // __algopy_default_create_L1 + let tmp%8#0: uint64 = (txn OnCompletion) + let tmp%9#0: bool = (! tmp%8#0) + let tmp%10#0: uint64 = (txn ApplicationID) + let tmp%11#0: bool = (! tmp%10#0) + let tmp%12#0: bool = (&& tmp%9#0 tmp%11#0) + (assert tmp%12#0) + exit 1u + +subroutine test_cases.structure_methods.contract.GroupedMethods.never_inlined_usually_inlined(v: uint64) -> uint64: + block@0: // L40 + let tmp%0#0: uint64 = (+ v#0 1u) + return tmp%0#0 + +subroutine test_cases.structure_methods.contract.GroupedMethods.not_usually_inlined(v: uint64) -> void: + block@0: // L58 + let aggregate%val_as_bytes%0#0: bytes[8] = (itob v#0) + let event%0#0: bytes = (concat method "ARC4TestStruct(uint64)" aggregate%val_as_bytes%0#0) + (log event%0#0) + (log event%0#0) + (log event%0#0) + (log event%0#0) + (log event%0#0) + (log event%0#0) + (log event%0#0) + (log event%0#0) + return \ No newline at end of file diff --git a/test_cases/structure_methods/out_O2/TestContract.ir/TestContract.clear.400.destructured.ir b/test_cases/structure_methods/out_O2/TestContract.ir/TestContract.clear.400.destructured.ir new file mode 100644 index 0000000000..b19ab730e7 --- /dev/null +++ b/test_cases/structure_methods/out_O2/TestContract.ir/TestContract.clear.400.destructured.ir @@ -0,0 +1,3 @@ +main algopy.arc4.ARC4Contract.clear_state_program: + block@0: // L1 + return 1u \ No newline at end of file diff --git a/test_cases/structure_methods/out_unoptimized/TestContract.approval.puya.map b/test_cases/structure_methods/out_unoptimized/TestContract.approval.puya.map new file mode 100644 index 0000000000..2221ce9b71 --- /dev/null +++ b/test_cases/structure_methods/out_unoptimized/TestContract.approval.puya.map @@ -0,0 +1,4207 @@ +{ + "version": 3, + "sources": [ + "../contract.py" + ], + "mappings": ";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAoEA;;AAAA;AAAA;AAAA;;;AAAA;;;AAAA;;;AAAA;;;;;;AAAA;;AAAA;;;;AAAA;;;;;;AAAA;AACK;;AAAA;AAAA;AAAA;;AAAA;AAAA;AAAA;AAAA;AAAA;;;;;;;;;;;;;;;;;;;;;;;;AA7DD;;;;;;AACW;;AAAA;AAAA;;AAAA;AAAA;AAAA;;AAAA;AAAP;;AAAA;;;;AAIO;AAAP;AAMJ;;;;;;AACW;;AAAA;AAAA;;AAAA;AAAA;AAAA;;AAAA;AAAP;;AAAA;;;;AAIO;AAAP;AAMJ;;;;;;AACW;;AAAA;;AAAA;AAAP;;;;AAIO;AAAP;AAIH;;;;;;AAEU;;AAAI;AAAJ;AAAP;AAaJ;;;;;;AACW;;AAAI;AAAJ;AAAP;AAEJ;;;;;;AAC6B;;AAAA;AAAf;AAAA;;AAAA;AAAV;AAAA;;AAAA;AAAA;AACyB;;AAAA;AAAf;AAAA;;AAAA;AAAV;AAAA;;AAAA;AAAA;AACyB;;AAAA;AAAf;AAAA;;AAAA;AAAV;AAAA;;AAAA;AAAA;AACyB;;AAAA;AAAf;AAAA;;AAAA;AAAV;AAAA;;AAAA;AAAA;AACyB;;AAAA;AAAf;AAAA;;AAAA;AAAV;AAAA;;AAAA;AAAA;AACyB;;AAAA;AAAf;AAAA;;AAAA;AAAV;AAAA;;AAAA;AAAA;AACyB;;AAAA;AAAf;AAAA;;AAAA;AAAV;AAAA;;AAAA;AAAA;AACyB;;AAAA;AAAf;AAAA;;AAAA;AAAV;AAAA;;AAAA;AAAA;;;;;AAIH;;;AAAA;AAAA;AAAA;;;;;;AAGwB;AAAe;AAAf;AAAkD;AAAlD;;;AAAA;;AAAd;AAAA;AAAP;AACgC;;AAAX;AAAA;AAAA;;AAAA;AAAyC;AAAzC;;;AAAA;;AAAd;AAAA;AAAP;AACoC;;AAA8B;AAA7C;;;AAAd;AAAA;AAAP;AAII;AAAe;AAAf;AAAgC;AADf;;;AAAA;;AAAd;AAAA;AAAP;AAG8D;;AAAX;AAAA;AAAA;;AAAA;AAAuB;AAArD;;;AAAA;;AAAd;AAAA;AAAP;AAEmB;;AAAY;AADV;;;AAAd;AAAA;AAAP;AAKoB;;;AAAb;AAAA;AAAP;AACoB;;;AAAb;AAAA;AAAP;AACoB;;;AAAb;AAAA;AAAP;AAGoB;;;AAAb;AAAA;AAAP;AACoB;;;AAAb;AAAA;AAAP;AACoB;;;AAAb;AAAA;AAAP;AAOmE;AAA/C;;;AAAb;;AAAA;AAAP;AACmE;AAA/C;;;AAAb;;AAAA;AAAP;AACqD;AAAjC;;;AAAb;;AAAA;AAAP;AACqD;AAAjC;;;AAAb;;AAAA;AAAP;AACA;;;AAAoD;AA3D3B;AAAf;AAAA;;AAAA;AAAV;AAAA;;AAAA;AAAA;AA2DoD;AA1D3B;AAAf;AAAA;;AAAA;AAAV;AAAA;;AAAA;AAAA;AA0DoD;AAzD3B;AAAf;AAAA;;AAAA;AAAV;AAAA;;AAAA;AAAA;AAyDoD;AAxD3B;AAAf;AAAA;;AAAA;AAAV;AAAA;;AAAA;AAAA;AAwDoD;AAvD3B;AAAf;AAAA;;AAAA;AAAV;AAAA;;AAAA;AAAA;AAuDoD;AAtD3B;AAAf;AAAA;;AAAA;AAAV;AAAA;;AAAA;AAAA;AAsDoD;AArD3B;AAAf;AAAA;;AAAA;AAAV;AAAA;;AAAA;AAAA;AAqDoD;AApD3B;AAAf;AAAA;;AAAA;AAAV;AAAA;;AAAA;AAAA;AAoDA;;;AACA;;;AAAoD;AA5D3B;AAAf;AAAA;;AAAA;AAAV;AAAA;;AAAA;AAAA;AA4DoD;AA3D3B;AAAf;AAAA;;AAAA;AAAV;AAAA;;AAAA;AAAA;AA2DoD;AA1D3B;AAAf;AAAA;;AAAA;AAAV;AAAA;;AAAA;AAAA;AA0DoD;AAzD3B;AAAf;AAAA;;AAAA;AAAV;AAAA;;AAAA;AAAA;AAyDoD;AAxD3B;AAAf;AAAA;;AAAA;AAAV;AAAA;;AAAA;AAAA;AAwDoD;AAvD3B;AAAf;AAAA;;AAAA;AAAV;AAAA;;AAAA;AAAA;AAuDoD;AAtD3B;AAAf;AAAA;;AAAA;AAAV;AAAA;;AAAA;AAAA;AAsDoD;AArD3B;AAAf;AAAA;;AAAA;AAAV;AAAA;;AAAA;AAAA;AAqDA;;;AACqC;AAArC;;;AACqC;AAArC;;;", + "op_pc_offset": 0, + "pc_events": { + "1": { + "subroutine": "algopy.arc4.ARC4Contract.approval_program", + "params": {}, + "block": "main", + "stack_in": [], + "op": "intcblock 2 1 0 18" + }, + "7": { + "op": "bytecblock 0x 0xed3267e8 0x0000000000000009" + }, + "24": { + "op": "b main_block@0" + }, + "27": { + "block": "main_block@0", + "stack_in": [], + "op": "b main_block@1" + }, + "30": { + "block": "main_block@1", + "stack_in": [], + "op": "txn NumAppArgs", + "defined_out": [ + "tmp%0#1" + ], + "stack_out": [ + "tmp%0#1" + ] + }, + "32": { + "op": "intc_2 // 0", + "defined_out": [ + "0", + "tmp%0#1" + ], + "stack_out": [ + "tmp%0#1", + "0" + ] + }, + "33": { + "op": "!=", + "defined_out": [ + "tmp%1#0" + ], + "stack_out": [ + "tmp%1#0" + ] + }, + "34": { + "op": "bz main___algopy_default_create@5", + "stack_out": [] + }, + "37": { + "op": "b main_abi_routing@2" + }, + "40": { + "block": "main_abi_routing@2", + "stack_in": [], + "op": "txna ApplicationArgs 0", + "defined_out": [ + "tmp%2#0" + ], + "stack_out": [ + "tmp%2#0" + ] + }, + "43": { + "op": "pushbytes 0xa78000de // method \"test()void\"", + "defined_out": [ + "Method(test()void)", + "tmp%2#0" + ], + "stack_out": [ + "tmp%2#0", + "Method(test()void)" + ] + }, + "49": { + "op": "uncover 1", + "stack_out": [ + "Method(test()void)", + "tmp%2#0" + ] + }, + "51": { + "op": "match main_test_route@3", + "stack_out": [] + }, + "55": { + "op": "b main_switch_case_next@4" + }, + "58": { + "block": "main_switch_case_next@4", + "stack_in": [], + "op": "b main_after_if_else@6" + }, + "61": { + "block": "main_after_if_else@6", + "stack_in": [], + "op": "err", + "defined_out": [] + }, + "62": { + "block": "main_test_route@3", + "stack_in": [], + "op": "txn OnCompletion", + "defined_out": [ + "tmp%3#0" + ], + "stack_out": [ + "tmp%3#0" + ] + }, + "64": { + "op": "intc_2 // NoOp", + "defined_out": [ + "NoOp", + "tmp%3#0" + ], + "stack_out": [ + "tmp%3#0", + "NoOp" + ] + }, + "65": { + "op": "==", + "defined_out": [ + "tmp%4#0" + ], + "stack_out": [ + "tmp%4#0" + ] + }, + "66": { + "op": "txn ApplicationID", + "defined_out": [ + "tmp%4#0", + "tmp%5#0" + ], + "stack_out": [ + "tmp%4#0", + "tmp%5#0" + ] + }, + "68": { + "op": "intc_2 // 0", + "defined_out": [ + "0", + "tmp%4#0", + "tmp%5#0" + ], + "stack_out": [ + "tmp%4#0", + "tmp%5#0", + "0" + ] + }, + "69": { + "op": "!=", + "defined_out": [ + "tmp%4#0", + "tmp%6#0" + ], + "stack_out": [ + "tmp%4#0", + "tmp%6#0" + ] + }, + "70": { + "op": "&&", + "defined_out": [ + "tmp%7#0" + ], + "stack_out": [ + "tmp%7#0" + ] + }, + "71": { + "op": "assert", + "stack_out": [] + }, + "72": { + "callsub": "test_cases.structure_methods.contract.TestContract.test[routing]", + "op": "callsub test" + }, + "75": { + "op": "b main_switch_case_next@4" + }, + "78": { + "block": "main___algopy_default_create@5", + "stack_in": [], + "op": "txn OnCompletion", + "defined_out": [ + "tmp%8#0" + ], + "stack_out": [ + "tmp%8#0" + ] + }, + "80": { + "op": "intc_2 // NoOp", + "defined_out": [ + "NoOp", + "tmp%8#0" + ], + "stack_out": [ + "tmp%8#0", + "NoOp" + ] + }, + "81": { + "op": "==", + "defined_out": [ + "tmp%9#0" + ], + "stack_out": [ + "tmp%9#0" + ] + }, + "82": { + "op": "txn ApplicationID", + "defined_out": [ + "tmp%10#0", + "tmp%9#0" + ], + "stack_out": [ + "tmp%9#0", + "tmp%10#0" + ] + }, + "84": { + "op": "intc_2 // 0", + "defined_out": [ + "0", + "tmp%10#0", + "tmp%9#0" + ], + "stack_out": [ + "tmp%9#0", + "tmp%10#0", + "0" + ] + }, + "85": { + "op": "==", + "defined_out": [ + "tmp%11#0", + "tmp%9#0" + ], + "stack_out": [ + "tmp%9#0", + "tmp%11#0" + ] + }, + "86": { + "op": "&&", + "defined_out": [ + "tmp%12#0" + ], + "stack_out": [ + "tmp%12#0" + ] + }, + "87": { + "op": "assert", + "stack_out": [] + }, + "88": { + "op": "b main_block@8" + }, + "91": { + "block": "main_block@8", + "stack_in": [], + "op": "b main_after_inlined_test_cases.structure_methods.contract.TestContract.__algopy_default_create@9" + }, + "94": { + "block": "main_after_inlined_test_cases.structure_methods.contract.TestContract.__algopy_default_create@9", + "stack_in": [], + "op": "intc_1 // 1", + "defined_out": [ + "1" + ], + "stack_out": [ + "1" + ] + }, + "95": { + "op": "return", + "stack_out": [] + }, + "96": { + "subroutine": "test_cases.structure_methods.contract.ARC4TestStruct.return_value_times", + "params": { + "self#0": "bytes", + "times#0": "uint64" + }, + "block": "return_value_times", + "stack_in": [], + "op": "proto 2 2" + }, + "99": { + "op": "b return_value_times_block@0" + }, + "102": { + "block": "return_value_times_block@0", + "stack_in": [], + "op": "frame_dig -2", + "defined_out": [ + "self#0 (copy)" + ], + "stack_out": [ + "self#0 (copy)" + ] + }, + "104": { + "op": "intc_2 // 0", + "defined_out": [ + "0", + "self#0 (copy)" + ], + "stack_out": [ + "self#0 (copy)", + "0" + ] + }, + "105": { + "op": "pushint 8", + "defined_out": [ + "0", + "8", + "self#0 (copy)" + ], + "stack_out": [ + "self#0 (copy)", + "0", + "8" + ] + }, + "107": { + "op": "extract3", + "defined_out": [ + "tuple_item%0#0" + ], + "stack_out": [ + "tuple_item%0#0" + ] + }, + "108": { + "op": "btoi", + "defined_out": [ + "tmp%0#0" + ], + "stack_out": [ + "tmp%0#0" + ] + }, + "109": { + "op": "frame_dig -1", + "defined_out": [ + "times#0 (copy)", + "tmp%0#0" + ], + "stack_out": [ + "tmp%0#0", + "times#0 (copy)" + ] + }, + "111": { + "op": "*", + "defined_out": [ + "tmp%1#0" + ], + "stack_out": [ + "tmp%1#0" + ] + }, + "112": { + "op": "frame_dig -2", + "stack_out": [ + "tmp%1#0", + "self#0 (copy)" + ] + }, + "114": { + "retsub": true, + "op": "retsub" + }, + "115": { + "subroutine": "test_cases.structure_methods.contract.ARC4TestStruct.return1", + "params": {}, + "block": "return1", + "stack_in": [], + "op": "b return1_block@0" + }, + "118": { + "block": "return1_block@0", + "stack_in": [], + "op": "intc_1 // 1", + "defined_out": [ + "1" + ], + "stack_out": [ + "1" + ] + }, + "119": { + "retsub": true, + "op": "retsub" + }, + "120": { + "subroutine": "test_cases.structure_methods.contract.TestStruct.return_value_times", + "params": { + "self#0": "bytes", + "times#0": "uint64" + }, + "block": "test_cases.structure_methods.contract.TestStruct.return_value_times", + "stack_in": [], + "op": "proto 2 2" + }, + "123": { + "op": "b test_cases.structure_methods.contract.TestStruct.return_value_times_block@0" + }, + "126": { + "block": "test_cases.structure_methods.contract.TestStruct.return_value_times_block@0", + "stack_in": [], + "op": "frame_dig -2", + "defined_out": [ + "self#0 (copy)" + ], + "stack_out": [ + "self#0 (copy)" + ] + }, + "128": { + "op": "intc_2 // 0", + "defined_out": [ + "0", + "self#0 (copy)" + ], + "stack_out": [ + "self#0 (copy)", + "0" + ] + }, + "129": { + "op": "pushint 8", + "defined_out": [ + "0", + "8", + "self#0 (copy)" + ], + "stack_out": [ + "self#0 (copy)", + "0", + "8" + ] + }, + "131": { + "op": "extract3", + "defined_out": [ + "tuple_item%0#0" + ], + "stack_out": [ + "tuple_item%0#0" + ] + }, + "132": { + "op": "btoi", + "defined_out": [ + "values%0#0" + ], + "stack_out": [ + "values%0#0" + ] + }, + "133": { + "op": "frame_dig -1", + "defined_out": [ + "times#0 (copy)", + "values%0#0" + ], + "stack_out": [ + "values%0#0", + "times#0 (copy)" + ] + }, + "135": { + "op": "*", + "defined_out": [ + "tmp%0#0" + ], + "stack_out": [ + "tmp%0#0" + ] + }, + "136": { + "op": "frame_dig -2", + "stack_out": [ + "tmp%0#0", + "self#0 (copy)" + ] + }, + "138": { + "retsub": true, + "op": "retsub" + }, + "139": { + "subroutine": "test_cases.structure_methods.contract.TestStruct.return1", + "params": {}, + "block": "test_cases.structure_methods.contract.TestStruct.return1", + "stack_in": [], + "op": "b test_cases.structure_methods.contract.TestStruct.return1_block@0" + }, + "142": { + "block": "test_cases.structure_methods.contract.TestStruct.return1_block@0", + "stack_in": [], + "op": "intc_1 // 1", + "defined_out": [ + "1" + ], + "stack_out": [ + "1" + ] + }, + "143": { + "retsub": true, + "op": "retsub" + }, + "144": { + "subroutine": "test_cases.structure_methods.contract.TestNamedTuple.return_value_times", + "params": { + "self.value#0": "uint64", + "times#0": "uint64" + }, + "block": "test_cases.structure_methods.contract.TestNamedTuple.return_value_times", + "stack_in": [], + "op": "proto 2 1" + }, + "147": { + "op": "b test_cases.structure_methods.contract.TestNamedTuple.return_value_times_block@0" + }, + "150": { + "block": "test_cases.structure_methods.contract.TestNamedTuple.return_value_times_block@0", + "stack_in": [], + "op": "frame_dig -2", + "defined_out": [ + "self.value#0 (copy)" + ], + "stack_out": [ + "self.value#0 (copy)" + ] + }, + "152": { + "op": "frame_dig -1", + "defined_out": [ + "self.value#0 (copy)", + "times#0 (copy)" + ], + "stack_out": [ + "self.value#0 (copy)", + "times#0 (copy)" + ] + }, + "154": { + "op": "*", + "defined_out": [ + "tmp%0#0" + ], + "stack_out": [ + "tmp%0#0" + ] + }, + "155": { + "retsub": true, + "op": "retsub" + }, + "156": { + "subroutine": "test_cases.structure_methods.contract.TestNamedTuple.return1", + "params": {}, + "block": "test_cases.structure_methods.contract.TestNamedTuple.return1", + "stack_in": [], + "op": "b test_cases.structure_methods.contract.TestNamedTuple.return1_block@0" + }, + "159": { + "block": "test_cases.structure_methods.contract.TestNamedTuple.return1_block@0", + "stack_in": [], + "op": "intc_1 // 1", + "defined_out": [ + "1" + ], + "stack_out": [ + "1" + ] + }, + "160": { + "retsub": true, + "op": "retsub" + }, + "161": { + "subroutine": "test_cases.structure_methods.contract.GroupedMethods.never_inlined_usually_inlined", + "params": { + "v#0": "uint64" + }, + "block": "never_inlined_usually_inlined", + "stack_in": [], + "op": "proto 1 1" + }, + "164": { + "op": "b never_inlined_usually_inlined_block@0" + }, + "167": { + "block": "never_inlined_usually_inlined_block@0", + "stack_in": [], + "op": "frame_dig -1", + "defined_out": [ + "v#0 (copy)" + ], + "stack_out": [ + "v#0 (copy)" + ] + }, + "169": { + "op": "intc_1 // 1", + "defined_out": [ + "1", + "v#0 (copy)" + ], + "stack_out": [ + "v#0 (copy)", + "1" + ] + }, + "170": { + "op": "+", + "defined_out": [ + "tmp%0#0" + ], + "stack_out": [ + "tmp%0#0" + ] + }, + "171": { + "retsub": true, + "op": "retsub" + }, + "172": { + "subroutine": "test_cases.structure_methods.contract.GroupedMethods.usually_inlined", + "params": { + "v#0": "uint64" + }, + "block": "usually_inlined", + "stack_in": [], + "op": "proto 1 1" + }, + "175": { + "op": "b usually_inlined_block@0" + }, + "178": { + "block": "usually_inlined_block@0", + "stack_in": [], + "op": "frame_dig -1", + "defined_out": [ + "v#0 (copy)" + ], + "stack_out": [ + "v#0 (copy)" + ] + }, + "180": { + "op": "intc_1 // 1", + "defined_out": [ + "1", + "v#0 (copy)" + ], + "stack_out": [ + "v#0 (copy)", + "1" + ] + }, + "181": { + "op": "+", + "defined_out": [ + "tmp%0#0" + ], + "stack_out": [ + "tmp%0#0" + ] + }, + "182": { + "retsub": true, + "op": "retsub" + }, + "183": { + "subroutine": "test_cases.structure_methods.contract.GroupedMethods.not_usually_inlined", + "params": { + "v#0": "uint64" + }, + "block": "not_usually_inlined", + "stack_in": [], + "op": "proto 1 0" + }, + "186": { + "op": "b not_usually_inlined_block@0" + }, + "189": { + "block": "not_usually_inlined_block@0", + "stack_in": [], + "op": "frame_dig -1", + "defined_out": [ + "v#0 (copy)" + ], + "stack_out": [ + "v#0 (copy)" + ] + }, + "191": { + "op": "itob", + "defined_out": [ + "tmp%0#0" + ], + "stack_out": [ + "tmp%0#0" + ] + }, + "192": { + "op": "bytec_0 // 0x", + "defined_out": [ + "0x", + "tmp%0#0" + ], + "stack_out": [ + "tmp%0#0", + "0x" + ] + }, + "193": { + "op": "uncover 1", + "stack_out": [ + "0x", + "tmp%0#0" + ] + }, + "195": { + "op": "concat", + "defined_out": [ + "tmp%1#0" + ], + "stack_out": [ + "tmp%1#0" + ] + }, + "196": { + "op": "bytec_1 // method \"ARC4TestStruct(uint64)\"", + "defined_out": [ + "Method(ARC4TestStruct(uint64))", + "tmp%1#0" + ], + "stack_out": [ + "tmp%1#0", + "Method(ARC4TestStruct(uint64))" + ] + }, + "197": { + "op": "uncover 1", + "stack_out": [ + "Method(ARC4TestStruct(uint64))", + "tmp%1#0" + ] + }, + "199": { + "op": "concat", + "defined_out": [ + "event%0#0" + ], + "stack_out": [ + "event%0#0" + ] + }, + "200": { + "op": "log", + "stack_out": [] + }, + "201": { + "op": "frame_dig -1", + "stack_out": [ + "v#0 (copy)" + ] + }, + "203": { + "op": "itob", + "defined_out": [ + "tmp%2#0" + ], + "stack_out": [ + "tmp%2#0" + ] + }, + "204": { + "op": "bytec_0 // 0x", + "stack_out": [ + "tmp%2#0", + "0x" + ] + }, + "205": { + "op": "uncover 1", + "stack_out": [ + "0x", + "tmp%2#0" + ] + }, + "207": { + "op": "concat", + "defined_out": [ + "tmp%3#0" + ], + "stack_out": [ + "tmp%3#0" + ] + }, + "208": { + "op": "bytec_1 // method \"ARC4TestStruct(uint64)\"", + "stack_out": [ + "tmp%3#0", + "Method(ARC4TestStruct(uint64))" + ] + }, + "209": { + "op": "uncover 1", + "stack_out": [ + "Method(ARC4TestStruct(uint64))", + "tmp%3#0" + ] + }, + "211": { + "op": "concat", + "defined_out": [ + "event%1#0" + ], + "stack_out": [ + "event%1#0" + ] + }, + "212": { + "op": "log", + "stack_out": [] + }, + "213": { + "op": "frame_dig -1", + "stack_out": [ + "v#0 (copy)" + ] + }, + "215": { + "op": "itob", + "defined_out": [ + "tmp%4#0" + ], + "stack_out": [ + "tmp%4#0" + ] + }, + "216": { + "op": "bytec_0 // 0x", + "stack_out": [ + "tmp%4#0", + "0x" + ] + }, + "217": { + "op": "uncover 1", + "stack_out": [ + "0x", + "tmp%4#0" + ] + }, + "219": { + "op": "concat", + "defined_out": [ + "tmp%5#0" + ], + "stack_out": [ + "tmp%5#0" + ] + }, + "220": { + "op": "bytec_1 // method \"ARC4TestStruct(uint64)\"", + "stack_out": [ + "tmp%5#0", + "Method(ARC4TestStruct(uint64))" + ] + }, + "221": { + "op": "uncover 1", + "stack_out": [ + "Method(ARC4TestStruct(uint64))", + "tmp%5#0" + ] + }, + "223": { + "op": "concat", + "defined_out": [ + "event%2#0" + ], + "stack_out": [ + "event%2#0" + ] + }, + "224": { + "op": "log", + "stack_out": [] + }, + "225": { + "op": "frame_dig -1", + "stack_out": [ + "v#0 (copy)" + ] + }, + "227": { + "op": "itob", + "defined_out": [ + "tmp%6#0" + ], + "stack_out": [ + "tmp%6#0" + ] + }, + "228": { + "op": "bytec_0 // 0x", + "stack_out": [ + "tmp%6#0", + "0x" + ] + }, + "229": { + "op": "uncover 1", + "stack_out": [ + "0x", + "tmp%6#0" + ] + }, + "231": { + "op": "concat", + "defined_out": [ + "tmp%7#0" + ], + "stack_out": [ + "tmp%7#0" + ] + }, + "232": { + "op": "bytec_1 // method \"ARC4TestStruct(uint64)\"", + "stack_out": [ + "tmp%7#0", + "Method(ARC4TestStruct(uint64))" + ] + }, + "233": { + "op": "uncover 1", + "stack_out": [ + "Method(ARC4TestStruct(uint64))", + "tmp%7#0" + ] + }, + "235": { + "op": "concat", + "defined_out": [ + "event%3#0" + ], + "stack_out": [ + "event%3#0" + ] + }, + "236": { + "op": "log", + "stack_out": [] + }, + "237": { + "op": "frame_dig -1", + "stack_out": [ + "v#0 (copy)" + ] + }, + "239": { + "op": "itob", + "defined_out": [ + "tmp%8#0" + ], + "stack_out": [ + "tmp%8#0" + ] + }, + "240": { + "op": "bytec_0 // 0x", + "stack_out": [ + "tmp%8#0", + "0x" + ] + }, + "241": { + "op": "uncover 1", + "stack_out": [ + "0x", + "tmp%8#0" + ] + }, + "243": { + "op": "concat", + "defined_out": [ + "tmp%9#0" + ], + "stack_out": [ + "tmp%9#0" + ] + }, + "244": { + "op": "bytec_1 // method \"ARC4TestStruct(uint64)\"", + "stack_out": [ + "tmp%9#0", + "Method(ARC4TestStruct(uint64))" + ] + }, + "245": { + "op": "uncover 1", + "stack_out": [ + "Method(ARC4TestStruct(uint64))", + "tmp%9#0" + ] + }, + "247": { + "op": "concat", + "defined_out": [ + "event%4#0" + ], + "stack_out": [ + "event%4#0" + ] + }, + "248": { + "op": "log", + "stack_out": [] + }, + "249": { + "op": "frame_dig -1", + "stack_out": [ + "v#0 (copy)" + ] + }, + "251": { + "op": "itob", + "defined_out": [ + "tmp%10#0" + ], + "stack_out": [ + "tmp%10#0" + ] + }, + "252": { + "op": "bytec_0 // 0x", + "stack_out": [ + "tmp%10#0", + "0x" + ] + }, + "253": { + "op": "uncover 1", + "stack_out": [ + "0x", + "tmp%10#0" + ] + }, + "255": { + "op": "concat", + "defined_out": [ + "tmp%11#0" + ], + "stack_out": [ + "tmp%11#0" + ] + }, + "256": { + "op": "bytec_1 // method \"ARC4TestStruct(uint64)\"", + "stack_out": [ + "tmp%11#0", + "Method(ARC4TestStruct(uint64))" + ] + }, + "257": { + "op": "uncover 1", + "stack_out": [ + "Method(ARC4TestStruct(uint64))", + "tmp%11#0" + ] + }, + "259": { + "op": "concat", + "defined_out": [ + "event%5#0" + ], + "stack_out": [ + "event%5#0" + ] + }, + "260": { + "op": "log", + "stack_out": [] + }, + "261": { + "op": "frame_dig -1", + "stack_out": [ + "v#0 (copy)" + ] + }, + "263": { + "op": "itob", + "defined_out": [ + "tmp%12#0" + ], + "stack_out": [ + "tmp%12#0" + ] + }, + "264": { + "op": "bytec_0 // 0x", + "stack_out": [ + "tmp%12#0", + "0x" + ] + }, + "265": { + "op": "uncover 1", + "stack_out": [ + "0x", + "tmp%12#0" + ] + }, + "267": { + "op": "concat", + "defined_out": [ + "tmp%13#0" + ], + "stack_out": [ + "tmp%13#0" + ] + }, + "268": { + "op": "bytec_1 // method \"ARC4TestStruct(uint64)\"", + "stack_out": [ + "tmp%13#0", + "Method(ARC4TestStruct(uint64))" + ] + }, + "269": { + "op": "uncover 1", + "stack_out": [ + "Method(ARC4TestStruct(uint64))", + "tmp%13#0" + ] + }, + "271": { + "op": "concat", + "defined_out": [ + "event%6#0" + ], + "stack_out": [ + "event%6#0" + ] + }, + "272": { + "op": "log", + "stack_out": [] + }, + "273": { + "op": "frame_dig -1", + "stack_out": [ + "v#0 (copy)" + ] + }, + "275": { + "op": "itob", + "defined_out": [ + "tmp%14#0" + ], + "stack_out": [ + "tmp%14#0" + ] + }, + "276": { + "op": "bytec_0 // 0x", + "stack_out": [ + "tmp%14#0", + "0x" + ] + }, + "277": { + "op": "uncover 1", + "stack_out": [ + "0x", + "tmp%14#0" + ] + }, + "279": { + "op": "concat", + "defined_out": [ + "tmp%15#0" + ], + "stack_out": [ + "tmp%15#0" + ] + }, + "280": { + "op": "bytec_1 // method \"ARC4TestStruct(uint64)\"", + "stack_out": [ + "tmp%15#0", + "Method(ARC4TestStruct(uint64))" + ] + }, + "281": { + "op": "uncover 1", + "stack_out": [ + "Method(ARC4TestStruct(uint64))", + "tmp%15#0" + ] + }, + "283": { + "op": "concat", + "defined_out": [ + "event%7#0" + ], + "stack_out": [ + "event%7#0" + ] + }, + "284": { + "op": "log", + "stack_out": [] + }, + "285": { + "retsub": true, + "op": "retsub" + }, + "286": { + "subroutine": "test_cases.structure_methods.contract.TestContract.test[routing]", + "params": {}, + "block": "test", + "stack_in": [], + "op": "b test_block@0" + }, + "289": { + "block": "test_block@0", + "stack_in": [], + "callsub": "test_cases.structure_methods.contract.TestContract.test", + "op": "callsub test_cases.structure_methods.contract.TestContract.test" + }, + "292": { + "op": "intc_1 // 1", + "defined_out": [ + "1" + ], + "stack_out": [ + "1" + ] + }, + "293": { + "op": "return", + "stack_out": [] + }, + "294": { + "subroutine": "test_cases.structure_methods.contract.TestContract.test", + "params": {}, + "block": "test_cases.structure_methods.contract.TestContract.test", + "stack_in": [], + "op": "proto 0 0" + }, + "297": { + "op": "b test_cases.structure_methods.contract.TestContract.test_block@0" + }, + "300": { + "block": "test_cases.structure_methods.contract.TestContract.test_block@0", + "stack_in": [], + "op": "bytec_0 // 0x", + "defined_out": [ + "0x" + ], + "stack_out": [ + "0x" + ] + }, + "301": { + "op": "bytec_2 // 0x0000000000000009", + "defined_out": [ + "0x", + "0x0000000000000009" + ], + "stack_out": [ + "0x", + "0x0000000000000009" + ] + }, + "302": { + "op": "concat", + "defined_out": [ + "tmp%0#0" + ], + "stack_out": [ + "tmp%0#0" + ] + }, + "303": { + "op": "intc_0 // 2", + "defined_out": [ + "2", + "tmp%0#0" + ], + "stack_out": [ + "tmp%0#0", + "2" + ] + }, + "304": { + "callsub": "test_cases.structure_methods.contract.ARC4TestStruct.return_value_times", + "op": "callsub return_value_times", + "defined_out": [ + "return_value_times%0#0", + "return_value_times%1#0" + ], + "stack_out": [ + "return_value_times%0#0", + "return_value_times%1#0" + ] + }, + "307": { + "op": "cover 1", + "defined_out": [ + "return_value_times%0#0", + "return_value_times%1#0" + ], + "stack_out": [ + "return_value_times%1#0", + "return_value_times%0#0" + ] + }, + "309": { + "op": "intc_3 // 18", + "defined_out": [ + "18", + "return_value_times%0#0", + "return_value_times%1#0" + ], + "stack_out": [ + "return_value_times%1#0", + "return_value_times%0#0", + "18" + ] + }, + "310": { + "op": "==", + "defined_out": [ + "return_value_times%1#0", + "tmp%1#0" + ], + "stack_out": [ + "return_value_times%1#0", + "tmp%1#0" + ] + }, + "311": { + "op": "assert", + "stack_out": [ + "return_value_times%1#0" + ] + }, + "312": { + "op": "pushint 9", + "defined_out": [ + "9", + "return_value_times%1#0" + ], + "stack_out": [ + "return_value_times%1#0", + "9" + ] + }, + "314": { + "op": "itob", + "defined_out": [ + "aggregate%as_Encoded(uint64)%1#0", + "return_value_times%1#0" + ], + "stack_out": [ + "return_value_times%1#0", + "aggregate%as_Encoded(uint64)%1#0" + ] + }, + "315": { + "op": "bytec_0 // 0x", + "stack_out": [ + "return_value_times%1#0", + "aggregate%as_Encoded(uint64)%1#0", + "0x" + ] + }, + "316": { + "op": "uncover 1", + "stack_out": [ + "return_value_times%1#0", + "0x", + "aggregate%as_Encoded(uint64)%1#0" + ] + }, + "318": { + "op": "concat", + "defined_out": [ + "return_value_times%1#0", + "tmp%2#0" + ], + "stack_out": [ + "return_value_times%1#0", + "tmp%2#0" + ] + }, + "319": { + "op": "intc_0 // 2", + "stack_out": [ + "return_value_times%1#0", + "tmp%2#0", + "2" + ] + }, + "320": { + "callsub": "test_cases.structure_methods.contract.TestStruct.return_value_times", + "op": "callsub test_cases.structure_methods.contract.TestStruct.return_value_times", + "defined_out": [ + "return_value_times%1#0", + "return_value_times%2#0", + "return_value_times%3#0" + ], + "stack_out": [ + "return_value_times%1#0", + "return_value_times%2#0", + "return_value_times%3#0" + ] + }, + "323": { + "op": "cover 1", + "defined_out": [ + "return_value_times%1#0", + "return_value_times%2#0", + "return_value_times%3#0" + ], + "stack_out": [ + "return_value_times%1#0", + "return_value_times%3#0", + "return_value_times%2#0" + ] + }, + "325": { + "op": "intc_3 // 18", + "stack_out": [ + "return_value_times%1#0", + "return_value_times%3#0", + "return_value_times%2#0", + "18" + ] + }, + "326": { + "op": "==", + "defined_out": [ + "return_value_times%1#0", + "return_value_times%3#0", + "tmp%3#0" + ], + "stack_out": [ + "return_value_times%1#0", + "return_value_times%3#0", + "tmp%3#0" + ] + }, + "327": { + "op": "assert", + "stack_out": [ + "return_value_times%1#0", + "return_value_times%3#0" + ] + }, + "328": { + "op": "pushint 9", + "stack_out": [ + "return_value_times%1#0", + "return_value_times%3#0", + "9" + ] + }, + "330": { + "op": "intc_0 // 2", + "stack_out": [ + "return_value_times%1#0", + "return_value_times%3#0", + "9", + "2" + ] + }, + "331": { + "callsub": "test_cases.structure_methods.contract.TestNamedTuple.return_value_times", + "op": "callsub test_cases.structure_methods.contract.TestNamedTuple.return_value_times", + "defined_out": [ + "return_value_times%1#0", + "return_value_times%3#0", + "tmp%4#0" + ], + "stack_out": [ + "return_value_times%1#0", + "return_value_times%3#0", + "tmp%4#0" + ] + }, + "334": { + "op": "intc_3 // 18", + "stack_out": [ + "return_value_times%1#0", + "return_value_times%3#0", + "tmp%4#0", + "18" + ] + }, + "335": { + "op": "==", + "defined_out": [ + "return_value_times%1#0", + "return_value_times%3#0", + "tmp%5#0" + ], + "stack_out": [ + "return_value_times%1#0", + "return_value_times%3#0", + "tmp%5#0" + ] + }, + "336": { + "op": "assert", + "stack_out": [ + "return_value_times%1#0", + "return_value_times%3#0" + ] + }, + "337": { + "op": "bytec_0 // 0x", + "stack_out": [ + "return_value_times%1#0", + "return_value_times%3#0", + "0x" + ] + }, + "338": { + "op": "bytec_2 // 0x0000000000000009", + "stack_out": [ + "return_value_times%1#0", + "return_value_times%3#0", + "0x", + "0x0000000000000009" + ] + }, + "339": { + "op": "concat", + "defined_out": [ + "return_value_times%1#0", + "return_value_times%3#0", + "tmp%6#0" + ], + "stack_out": [ + "return_value_times%1#0", + "return_value_times%3#0", + "tmp%6#0" + ] + }, + "340": { + "op": "intc_0 // 2", + "stack_out": [ + "return_value_times%1#0", + "return_value_times%3#0", + "tmp%6#0", + "2" + ] + }, + "341": { + "callsub": "test_cases.structure_methods.contract.ARC4TestStruct.return_value_times", + "op": "callsub return_value_times", + "defined_out": [ + "return_value_times%1#0", + "return_value_times%3#0", + "return_value_times%4#0", + "return_value_times%5#0" + ], + "stack_out": [ + "return_value_times%1#0", + "return_value_times%3#0", + "return_value_times%4#0", + "return_value_times%5#0" + ] + }, + "344": { + "op": "cover 1", + "defined_out": [ + "return_value_times%1#0", + "return_value_times%3#0", + "return_value_times%4#0", + "return_value_times%5#0" + ], + "stack_out": [ + "return_value_times%1#0", + "return_value_times%3#0", + "return_value_times%5#0", + "return_value_times%4#0" + ] + }, + "346": { + "op": "intc_3 // 18", + "stack_out": [ + "return_value_times%1#0", + "return_value_times%3#0", + "return_value_times%5#0", + "return_value_times%4#0", + "18" + ] + }, + "347": { + "op": "==", + "defined_out": [ + "return_value_times%1#0", + "return_value_times%3#0", + "return_value_times%5#0", + "tmp%7#0" + ], + "stack_out": [ + "return_value_times%1#0", + "return_value_times%3#0", + "return_value_times%5#0", + "tmp%7#0" + ] + }, + "348": { + "op": "assert", + "stack_out": [ + "return_value_times%1#0", + "return_value_times%3#0", + "return_value_times%5#0" + ] + }, + "349": { + "op": "pushint 9", + "stack_out": [ + "return_value_times%1#0", + "return_value_times%3#0", + "return_value_times%5#0", + "9" + ] + }, + "351": { + "op": "itob", + "defined_out": [ + "aggregate%as_Encoded(uint64)%4#0", + "return_value_times%1#0", + "return_value_times%3#0", + "return_value_times%5#0" + ], + "stack_out": [ + "return_value_times%1#0", + "return_value_times%3#0", + "return_value_times%5#0", + "aggregate%as_Encoded(uint64)%4#0" + ] + }, + "352": { + "op": "bytec_0 // 0x", + "stack_out": [ + "return_value_times%1#0", + "return_value_times%3#0", + "return_value_times%5#0", + "aggregate%as_Encoded(uint64)%4#0", + "0x" + ] + }, + "353": { + "op": "uncover 1", + "stack_out": [ + "return_value_times%1#0", + "return_value_times%3#0", + "return_value_times%5#0", + "0x", + "aggregate%as_Encoded(uint64)%4#0" + ] + }, + "355": { + "op": "concat", + "defined_out": [ + "return_value_times%1#0", + "return_value_times%3#0", + "return_value_times%5#0", + "tmp%8#0" + ], + "stack_out": [ + "return_value_times%1#0", + "return_value_times%3#0", + "return_value_times%5#0", + "tmp%8#0" + ] + }, + "356": { + "op": "intc_0 // 2", + "stack_out": [ + "return_value_times%1#0", + "return_value_times%3#0", + "return_value_times%5#0", + "tmp%8#0", + "2" + ] + }, + "357": { + "callsub": "test_cases.structure_methods.contract.TestStruct.return_value_times", + "op": "callsub test_cases.structure_methods.contract.TestStruct.return_value_times", + "defined_out": [ + "return_value_times%1#0", + "return_value_times%3#0", + "return_value_times%5#0", + "return_value_times%6#0", + "return_value_times%7#0" + ], + "stack_out": [ + "return_value_times%1#0", + "return_value_times%3#0", + "return_value_times%5#0", + "return_value_times%6#0", + "return_value_times%7#0" + ] + }, + "360": { + "op": "cover 1", + "defined_out": [ + "return_value_times%1#0", + "return_value_times%3#0", + "return_value_times%5#0", + "return_value_times%6#0", + "return_value_times%7#0" + ], + "stack_out": [ + "return_value_times%1#0", + "return_value_times%3#0", + "return_value_times%5#0", + "return_value_times%7#0", + "return_value_times%6#0" + ] + }, + "362": { + "op": "intc_3 // 18", + "stack_out": [ + "return_value_times%1#0", + "return_value_times%3#0", + "return_value_times%5#0", + "return_value_times%7#0", + "return_value_times%6#0", + "18" + ] + }, + "363": { + "op": "==", + "defined_out": [ + "return_value_times%1#0", + "return_value_times%3#0", + "return_value_times%5#0", + "return_value_times%7#0", + "tmp%9#0" + ], + "stack_out": [ + "return_value_times%1#0", + "return_value_times%3#0", + "return_value_times%5#0", + "return_value_times%7#0", + "tmp%9#0" + ] + }, + "364": { + "op": "assert", + "stack_out": [ + "return_value_times%1#0", + "return_value_times%3#0", + "return_value_times%5#0", + "return_value_times%7#0" + ] + }, + "365": { + "op": "pushint 9", + "stack_out": [ + "return_value_times%1#0", + "return_value_times%3#0", + "return_value_times%5#0", + "return_value_times%7#0", + "9" + ] + }, + "367": { + "op": "intc_0 // 2", + "stack_out": [ + "return_value_times%1#0", + "return_value_times%3#0", + "return_value_times%5#0", + "return_value_times%7#0", + "9", + "2" + ] + }, + "368": { + "callsub": "test_cases.structure_methods.contract.TestNamedTuple.return_value_times", + "op": "callsub test_cases.structure_methods.contract.TestNamedTuple.return_value_times", + "defined_out": [ + "return_value_times%1#0", + "return_value_times%3#0", + "return_value_times%5#0", + "return_value_times%7#0", + "tmp%10#0" + ], + "stack_out": [ + "return_value_times%1#0", + "return_value_times%3#0", + "return_value_times%5#0", + "return_value_times%7#0", + "tmp%10#0" + ] + }, + "371": { + "op": "intc_3 // 18", + "stack_out": [ + "return_value_times%1#0", + "return_value_times%3#0", + "return_value_times%5#0", + "return_value_times%7#0", + "tmp%10#0", + "18" + ] + }, + "372": { + "op": "==", + "defined_out": [ + "return_value_times%1#0", + "return_value_times%3#0", + "return_value_times%5#0", + "return_value_times%7#0", + "tmp%11#0" + ], + "stack_out": [ + "return_value_times%1#0", + "return_value_times%3#0", + "return_value_times%5#0", + "return_value_times%7#0", + "tmp%11#0" + ] + }, + "373": { + "op": "assert", + "stack_out": [ + "return_value_times%1#0", + "return_value_times%3#0", + "return_value_times%5#0", + "return_value_times%7#0" + ] + }, + "374": { + "callsub": "test_cases.structure_methods.contract.ARC4TestStruct.return1", + "op": "callsub return1", + "defined_out": [ + "return_value_times%1#0", + "return_value_times%3#0", + "return_value_times%5#0", + "return_value_times%7#0", + "tmp%12#0" + ], + "stack_out": [ + "return_value_times%1#0", + "return_value_times%3#0", + "return_value_times%5#0", + "return_value_times%7#0", + "tmp%12#0" + ] + }, + "377": { + "op": "intc_1 // 1", + "stack_out": [ + "return_value_times%1#0", + "return_value_times%3#0", + "return_value_times%5#0", + "return_value_times%7#0", + "tmp%12#0", + "1" + ] + }, + "378": { + "op": "==", + "defined_out": [ + "return_value_times%1#0", + "return_value_times%3#0", + "return_value_times%5#0", + "return_value_times%7#0", + "tmp%13#0" + ], + "stack_out": [ + "return_value_times%1#0", + "return_value_times%3#0", + "return_value_times%5#0", + "return_value_times%7#0", + "tmp%13#0" + ] + }, + "379": { + "op": "assert", + "stack_out": [ + "return_value_times%1#0", + "return_value_times%3#0", + "return_value_times%5#0", + "return_value_times%7#0" + ] + }, + "380": { + "callsub": "test_cases.structure_methods.contract.TestStruct.return1", + "op": "callsub test_cases.structure_methods.contract.TestStruct.return1", + "defined_out": [ + "return_value_times%1#0", + "return_value_times%3#0", + "return_value_times%5#0", + "return_value_times%7#0", + "tmp%14#0" + ], + "stack_out": [ + "return_value_times%1#0", + "return_value_times%3#0", + "return_value_times%5#0", + "return_value_times%7#0", + "tmp%14#0" + ] + }, + "383": { + "op": "intc_1 // 1", + "stack_out": [ + "return_value_times%1#0", + "return_value_times%3#0", + "return_value_times%5#0", + "return_value_times%7#0", + "tmp%14#0", + "1" + ] + }, + "384": { + "op": "==", + "defined_out": [ + "return_value_times%1#0", + "return_value_times%3#0", + "return_value_times%5#0", + "return_value_times%7#0", + "tmp%15#0" + ], + "stack_out": [ + "return_value_times%1#0", + "return_value_times%3#0", + "return_value_times%5#0", + "return_value_times%7#0", + "tmp%15#0" + ] + }, + "385": { + "op": "assert", + "stack_out": [ + "return_value_times%1#0", + "return_value_times%3#0", + "return_value_times%5#0", + "return_value_times%7#0" + ] + }, + "386": { + "callsub": "test_cases.structure_methods.contract.TestNamedTuple.return1", + "op": "callsub test_cases.structure_methods.contract.TestNamedTuple.return1", + "defined_out": [ + "return_value_times%1#0", + "return_value_times%3#0", + "return_value_times%5#0", + "return_value_times%7#0", + "tmp%16#0" + ], + "stack_out": [ + "return_value_times%1#0", + "return_value_times%3#0", + "return_value_times%5#0", + "return_value_times%7#0", + "tmp%16#0" + ] + }, + "389": { + "op": "intc_1 // 1", + "stack_out": [ + "return_value_times%1#0", + "return_value_times%3#0", + "return_value_times%5#0", + "return_value_times%7#0", + "tmp%16#0", + "1" + ] + }, + "390": { + "op": "==", + "defined_out": [ + "return_value_times%1#0", + "return_value_times%3#0", + "return_value_times%5#0", + "return_value_times%7#0", + "tmp%17#0" + ], + "stack_out": [ + "return_value_times%1#0", + "return_value_times%3#0", + "return_value_times%5#0", + "return_value_times%7#0", + "tmp%17#0" + ] + }, + "391": { + "op": "assert", + "stack_out": [ + "return_value_times%1#0", + "return_value_times%3#0", + "return_value_times%5#0", + "return_value_times%7#0" + ] + }, + "392": { + "callsub": "test_cases.structure_methods.contract.ARC4TestStruct.return1", + "op": "callsub return1", + "defined_out": [ + "return_value_times%1#0", + "return_value_times%3#0", + "return_value_times%5#0", + "return_value_times%7#0", + "tmp%18#0" + ], + "stack_out": [ + "return_value_times%1#0", + "return_value_times%3#0", + "return_value_times%5#0", + "return_value_times%7#0", + "tmp%18#0" + ] + }, + "395": { + "op": "intc_1 // 1", + "stack_out": [ + "return_value_times%1#0", + "return_value_times%3#0", + "return_value_times%5#0", + "return_value_times%7#0", + "tmp%18#0", + "1" + ] + }, + "396": { + "op": "==", + "defined_out": [ + "return_value_times%1#0", + "return_value_times%3#0", + "return_value_times%5#0", + "return_value_times%7#0", + "tmp%19#0" + ], + "stack_out": [ + "return_value_times%1#0", + "return_value_times%3#0", + "return_value_times%5#0", + "return_value_times%7#0", + "tmp%19#0" + ] + }, + "397": { + "op": "assert", + "stack_out": [ + "return_value_times%1#0", + "return_value_times%3#0", + "return_value_times%5#0", + "return_value_times%7#0" + ] + }, + "398": { + "callsub": "test_cases.structure_methods.contract.TestStruct.return1", + "op": "callsub test_cases.structure_methods.contract.TestStruct.return1", + "defined_out": [ + "return_value_times%1#0", + "return_value_times%3#0", + "return_value_times%5#0", + "return_value_times%7#0", + "tmp%20#0" + ], + "stack_out": [ + "return_value_times%1#0", + "return_value_times%3#0", + "return_value_times%5#0", + "return_value_times%7#0", + "tmp%20#0" + ] + }, + "401": { + "op": "intc_1 // 1", + "stack_out": [ + "return_value_times%1#0", + "return_value_times%3#0", + "return_value_times%5#0", + "return_value_times%7#0", + "tmp%20#0", + "1" + ] + }, + "402": { + "op": "==", + "defined_out": [ + "return_value_times%1#0", + "return_value_times%3#0", + "return_value_times%5#0", + "return_value_times%7#0", + "tmp%21#0" + ], + "stack_out": [ + "return_value_times%1#0", + "return_value_times%3#0", + "return_value_times%5#0", + "return_value_times%7#0", + "tmp%21#0" + ] + }, + "403": { + "op": "assert", + "stack_out": [ + "return_value_times%1#0", + "return_value_times%3#0", + "return_value_times%5#0", + "return_value_times%7#0" + ] + }, + "404": { + "callsub": "test_cases.structure_methods.contract.TestNamedTuple.return1", + "op": "callsub test_cases.structure_methods.contract.TestNamedTuple.return1", + "defined_out": [ + "return_value_times%1#0", + "return_value_times%3#0", + "return_value_times%5#0", + "return_value_times%7#0", + "tmp%22#0" + ], + "stack_out": [ + "return_value_times%1#0", + "return_value_times%3#0", + "return_value_times%5#0", + "return_value_times%7#0", + "tmp%22#0" + ] + }, + "407": { + "op": "intc_1 // 1", + "stack_out": [ + "return_value_times%1#0", + "return_value_times%3#0", + "return_value_times%5#0", + "return_value_times%7#0", + "tmp%22#0", + "1" + ] + }, + "408": { + "op": "==", + "defined_out": [ + "return_value_times%1#0", + "return_value_times%3#0", + "return_value_times%5#0", + "return_value_times%7#0", + "tmp%23#0" + ], + "stack_out": [ + "return_value_times%1#0", + "return_value_times%3#0", + "return_value_times%5#0", + "return_value_times%7#0", + "tmp%23#0" + ] + }, + "409": { + "op": "assert", + "stack_out": [ + "return_value_times%1#0", + "return_value_times%3#0", + "return_value_times%5#0", + "return_value_times%7#0" + ] + }, + "410": { + "op": "intc_0 // 2", + "stack_out": [ + "return_value_times%1#0", + "return_value_times%3#0", + "return_value_times%5#0", + "return_value_times%7#0", + "2" + ] + }, + "411": { + "callsub": "test_cases.structure_methods.contract.GroupedMethods.never_inlined_usually_inlined", + "op": "callsub never_inlined_usually_inlined", + "defined_out": [ + "return_value_times%1#0", + "return_value_times%3#0", + "return_value_times%5#0", + "return_value_times%7#0", + "tmp%24#0" + ], + "stack_out": [ + "return_value_times%1#0", + "return_value_times%3#0", + "return_value_times%5#0", + "return_value_times%7#0", + "tmp%24#0" + ] + }, + "414": { + "op": "pushint 3", + "stack_out": [ + "return_value_times%1#0", + "return_value_times%3#0", + "return_value_times%5#0", + "return_value_times%7#0", + "tmp%24#0", + "3" + ] + }, + "416": { + "op": "==", + "defined_out": [ + "return_value_times%1#0", + "return_value_times%3#0", + "return_value_times%5#0", + "return_value_times%7#0", + "tmp%25#0" + ], + "stack_out": [ + "return_value_times%1#0", + "return_value_times%3#0", + "return_value_times%5#0", + "return_value_times%7#0", + "tmp%25#0" + ] + }, + "417": { + "op": "assert", + "stack_out": [ + "return_value_times%1#0", + "return_value_times%3#0", + "return_value_times%5#0", + "return_value_times%7#0" + ] + }, + "418": { + "op": "intc_0 // 2", + "stack_out": [ + "return_value_times%1#0", + "return_value_times%3#0", + "return_value_times%5#0", + "return_value_times%7#0", + "2" + ] + }, + "419": { + "callsub": "test_cases.structure_methods.contract.GroupedMethods.never_inlined_usually_inlined", + "op": "callsub never_inlined_usually_inlined", + "defined_out": [ + "return_value_times%1#0", + "return_value_times%3#0", + "return_value_times%5#0", + "return_value_times%7#0", + "tmp%26#0" + ], + "stack_out": [ + "return_value_times%1#0", + "return_value_times%3#0", + "return_value_times%5#0", + "return_value_times%7#0", + "tmp%26#0" + ] + }, + "422": { + "op": "pushint 3", + "stack_out": [ + "return_value_times%1#0", + "return_value_times%3#0", + "return_value_times%5#0", + "return_value_times%7#0", + "tmp%26#0", + "3" + ] + }, + "424": { + "op": "==", + "defined_out": [ + "return_value_times%1#0", + "return_value_times%3#0", + "return_value_times%5#0", + "return_value_times%7#0", + "tmp%27#0" + ], + "stack_out": [ + "return_value_times%1#0", + "return_value_times%3#0", + "return_value_times%5#0", + "return_value_times%7#0", + "tmp%27#0" + ] + }, + "425": { + "op": "assert", + "stack_out": [ + "return_value_times%1#0", + "return_value_times%3#0", + "return_value_times%5#0", + "return_value_times%7#0" + ] + }, + "426": { + "op": "intc_0 // 2", + "stack_out": [ + "return_value_times%1#0", + "return_value_times%3#0", + "return_value_times%5#0", + "return_value_times%7#0", + "2" + ] + }, + "427": { + "callsub": "test_cases.structure_methods.contract.GroupedMethods.usually_inlined", + "op": "callsub usually_inlined", + "defined_out": [ + "return_value_times%1#0", + "return_value_times%3#0", + "return_value_times%5#0", + "return_value_times%7#0", + "tmp%28#0" + ], + "stack_out": [ + "return_value_times%1#0", + "return_value_times%3#0", + "return_value_times%5#0", + "return_value_times%7#0", + "tmp%28#0" + ] + }, + "430": { + "op": "pushint 3", + "stack_out": [ + "return_value_times%1#0", + "return_value_times%3#0", + "return_value_times%5#0", + "return_value_times%7#0", + "tmp%28#0", + "3" + ] + }, + "432": { + "op": "==", + "defined_out": [ + "return_value_times%1#0", + "return_value_times%3#0", + "return_value_times%5#0", + "return_value_times%7#0", + "tmp%29#0" + ], + "stack_out": [ + "return_value_times%1#0", + "return_value_times%3#0", + "return_value_times%5#0", + "return_value_times%7#0", + "tmp%29#0" + ] + }, + "433": { + "op": "assert", + "stack_out": [ + "return_value_times%1#0", + "return_value_times%3#0", + "return_value_times%5#0", + "return_value_times%7#0" + ] + }, + "434": { + "op": "intc_0 // 2", + "stack_out": [ + "return_value_times%1#0", + "return_value_times%3#0", + "return_value_times%5#0", + "return_value_times%7#0", + "2" + ] + }, + "435": { + "callsub": "test_cases.structure_methods.contract.GroupedMethods.usually_inlined", + "op": "callsub usually_inlined", + "defined_out": [ + "return_value_times%1#0", + "return_value_times%3#0", + "return_value_times%5#0", + "return_value_times%7#0", + "tmp%30#0" + ], + "stack_out": [ + "return_value_times%1#0", + "return_value_times%3#0", + "return_value_times%5#0", + "return_value_times%7#0", + "tmp%30#0" + ] + }, + "438": { + "op": "pushint 3", + "stack_out": [ + "return_value_times%1#0", + "return_value_times%3#0", + "return_value_times%5#0", + "return_value_times%7#0", + "tmp%30#0", + "3" + ] + }, + "440": { + "op": "==", + "defined_out": [ + "return_value_times%1#0", + "return_value_times%3#0", + "return_value_times%5#0", + "return_value_times%7#0", + "tmp%31#0" + ], + "stack_out": [ + "return_value_times%1#0", + "return_value_times%3#0", + "return_value_times%5#0", + "return_value_times%7#0", + "tmp%31#0" + ] + }, + "441": { + "op": "assert", + "stack_out": [ + "return_value_times%1#0", + "return_value_times%3#0", + "return_value_times%5#0", + "return_value_times%7#0" + ] + }, + "442": { + "op": "b test_cases.structure_methods.contract.TestContract.test_block@1" + }, + "445": { + "block": "test_cases.structure_methods.contract.TestContract.test_block@1", + "stack_in": [ + "return_value_times%1#0", + "return_value_times%3#0", + "return_value_times%5#0", + "return_value_times%7#0" + ], + "op": "intc_0 // 2", + "defined_out": [ + "2" + ], + "stack_out": [ + "return_value_times%1#0", + "return_value_times%3#0", + "return_value_times%5#0", + "return_value_times%7#0", + "2" + ] + }, + "446": { + "op": "itob", + "defined_out": [ + "tmp%0#0" + ], + "stack_out": [ + "return_value_times%1#0", + "return_value_times%3#0", + "return_value_times%5#0", + "return_value_times%7#0", + "tmp%0#0" + ] + }, + "447": { + "op": "bytec_0 // 0x", + "defined_out": [ + "0x", + "tmp%0#0" + ], + "stack_out": [ + "return_value_times%1#0", + "return_value_times%3#0", + "return_value_times%5#0", + "return_value_times%7#0", + "tmp%0#0", + "0x" + ] + }, + "448": { + "op": "uncover 1", + "stack_out": [ + "return_value_times%1#0", + "return_value_times%3#0", + "return_value_times%5#0", + "return_value_times%7#0", + "0x", + "tmp%0#0" + ] + }, + "450": { + "op": "concat", + "defined_out": [ + "tmp%1#1" + ], + "stack_out": [ + "return_value_times%1#0", + "return_value_times%3#0", + "return_value_times%5#0", + "return_value_times%7#0", + "tmp%1#1" + ] + }, + "451": { + "op": "bytec_1 // method \"ARC4TestStruct(uint64)\"", + "defined_out": [ + "Method(ARC4TestStruct(uint64))", + "tmp%1#1" + ], + "stack_out": [ + "return_value_times%1#0", + "return_value_times%3#0", + "return_value_times%5#0", + "return_value_times%7#0", + "tmp%1#1", + "Method(ARC4TestStruct(uint64))" + ] + }, + "452": { + "op": "uncover 1", + "stack_out": [ + "return_value_times%1#0", + "return_value_times%3#0", + "return_value_times%5#0", + "return_value_times%7#0", + "Method(ARC4TestStruct(uint64))", + "tmp%1#1" + ] + }, + "454": { + "op": "concat", + "defined_out": [ + "event%0#0" + ], + "stack_out": [ + "return_value_times%1#0", + "return_value_times%3#0", + "return_value_times%5#0", + "return_value_times%7#0", + "event%0#0" + ] + }, + "455": { + "op": "log", + "stack_out": [ + "return_value_times%1#0", + "return_value_times%3#0", + "return_value_times%5#0", + "return_value_times%7#0" + ] + }, + "456": { + "op": "intc_0 // 2", + "stack_out": [ + "return_value_times%1#0", + "return_value_times%3#0", + "return_value_times%5#0", + "return_value_times%7#0", + "2" + ] + }, + "457": { + "op": "itob", + "defined_out": [ + "tmp%2#0" + ], + "stack_out": [ + "return_value_times%1#0", + "return_value_times%3#0", + "return_value_times%5#0", + "return_value_times%7#0", + "tmp%2#0" + ] + }, + "458": { + "op": "bytec_0 // 0x", + "stack_out": [ + "return_value_times%1#0", + "return_value_times%3#0", + "return_value_times%5#0", + "return_value_times%7#0", + "tmp%2#0", + "0x" + ] + }, + "459": { + "op": "uncover 1", + "stack_out": [ + "return_value_times%1#0", + "return_value_times%3#0", + "return_value_times%5#0", + "return_value_times%7#0", + "0x", + "tmp%2#0" + ] + }, + "461": { + "op": "concat", + "defined_out": [ + "tmp%3#1" + ], + "stack_out": [ + "return_value_times%1#0", + "return_value_times%3#0", + "return_value_times%5#0", + "return_value_times%7#0", + "tmp%3#1" + ] + }, + "462": { + "op": "bytec_1 // method \"ARC4TestStruct(uint64)\"", + "stack_out": [ + "return_value_times%1#0", + "return_value_times%3#0", + "return_value_times%5#0", + "return_value_times%7#0", + "tmp%3#1", + "Method(ARC4TestStruct(uint64))" + ] + }, + "463": { + "op": "uncover 1", + "stack_out": [ + "return_value_times%1#0", + "return_value_times%3#0", + "return_value_times%5#0", + "return_value_times%7#0", + "Method(ARC4TestStruct(uint64))", + "tmp%3#1" + ] + }, + "465": { + "op": "concat", + "defined_out": [ + "event%1#0" + ], + "stack_out": [ + "return_value_times%1#0", + "return_value_times%3#0", + "return_value_times%5#0", + "return_value_times%7#0", + "event%1#0" + ] + }, + "466": { + "op": "log", + "stack_out": [ + "return_value_times%1#0", + "return_value_times%3#0", + "return_value_times%5#0", + "return_value_times%7#0" + ] + }, + "467": { + "op": "intc_0 // 2", + "stack_out": [ + "return_value_times%1#0", + "return_value_times%3#0", + "return_value_times%5#0", + "return_value_times%7#0", + "2" + ] + }, + "468": { + "op": "itob", + "defined_out": [ + "tmp%4#1" + ], + "stack_out": [ + "return_value_times%1#0", + "return_value_times%3#0", + "return_value_times%5#0", + "return_value_times%7#0", + "tmp%4#1" + ] + }, + "469": { + "op": "bytec_0 // 0x", + "stack_out": [ + "return_value_times%1#0", + "return_value_times%3#0", + "return_value_times%5#0", + "return_value_times%7#0", + "tmp%4#1", + "0x" + ] + }, + "470": { + "op": "uncover 1", + "stack_out": [ + "return_value_times%1#0", + "return_value_times%3#0", + "return_value_times%5#0", + "return_value_times%7#0", + "0x", + "tmp%4#1" + ] + }, + "472": { + "op": "concat", + "defined_out": [ + "tmp%5#1" + ], + "stack_out": [ + "return_value_times%1#0", + "return_value_times%3#0", + "return_value_times%5#0", + "return_value_times%7#0", + "tmp%5#1" + ] + }, + "473": { + "op": "bytec_1 // method \"ARC4TestStruct(uint64)\"", + "stack_out": [ + "return_value_times%1#0", + "return_value_times%3#0", + "return_value_times%5#0", + "return_value_times%7#0", + "tmp%5#1", + "Method(ARC4TestStruct(uint64))" + ] + }, + "474": { + "op": "uncover 1", + "stack_out": [ + "return_value_times%1#0", + "return_value_times%3#0", + "return_value_times%5#0", + "return_value_times%7#0", + "Method(ARC4TestStruct(uint64))", + "tmp%5#1" + ] + }, + "476": { + "op": "concat", + "defined_out": [ + "event%2#0" + ], + "stack_out": [ + "return_value_times%1#0", + "return_value_times%3#0", + "return_value_times%5#0", + "return_value_times%7#0", + "event%2#0" + ] + }, + "477": { + "op": "log", + "stack_out": [ + "return_value_times%1#0", + "return_value_times%3#0", + "return_value_times%5#0", + "return_value_times%7#0" + ] + }, + "478": { + "op": "intc_0 // 2", + "stack_out": [ + "return_value_times%1#0", + "return_value_times%3#0", + "return_value_times%5#0", + "return_value_times%7#0", + "2" + ] + }, + "479": { + "op": "itob", + "defined_out": [ + "tmp%6#0" + ], + "stack_out": [ + "return_value_times%1#0", + "return_value_times%3#0", + "return_value_times%5#0", + "return_value_times%7#0", + "tmp%6#0" + ] + }, + "480": { + "op": "bytec_0 // 0x", + "stack_out": [ + "return_value_times%1#0", + "return_value_times%3#0", + "return_value_times%5#0", + "return_value_times%7#0", + "tmp%6#0", + "0x" + ] + }, + "481": { + "op": "uncover 1", + "stack_out": [ + "return_value_times%1#0", + "return_value_times%3#0", + "return_value_times%5#0", + "return_value_times%7#0", + "0x", + "tmp%6#0" + ] + }, + "483": { + "op": "concat", + "defined_out": [ + "tmp%7#1" + ], + "stack_out": [ + "return_value_times%1#0", + "return_value_times%3#0", + "return_value_times%5#0", + "return_value_times%7#0", + "tmp%7#1" + ] + }, + "484": { + "op": "bytec_1 // method \"ARC4TestStruct(uint64)\"", + "stack_out": [ + "return_value_times%1#0", + "return_value_times%3#0", + "return_value_times%5#0", + "return_value_times%7#0", + "tmp%7#1", + "Method(ARC4TestStruct(uint64))" + ] + }, + "485": { + "op": "uncover 1", + "stack_out": [ + "return_value_times%1#0", + "return_value_times%3#0", + "return_value_times%5#0", + "return_value_times%7#0", + "Method(ARC4TestStruct(uint64))", + "tmp%7#1" + ] + }, + "487": { + "op": "concat", + "defined_out": [ + "event%3#0" + ], + "stack_out": [ + "return_value_times%1#0", + "return_value_times%3#0", + "return_value_times%5#0", + "return_value_times%7#0", + "event%3#0" + ] + }, + "488": { + "op": "log", + "stack_out": [ + "return_value_times%1#0", + "return_value_times%3#0", + "return_value_times%5#0", + "return_value_times%7#0" + ] + }, + "489": { + "op": "intc_0 // 2", + "stack_out": [ + "return_value_times%1#0", + "return_value_times%3#0", + "return_value_times%5#0", + "return_value_times%7#0", + "2" + ] + }, + "490": { + "op": "itob", + "defined_out": [ + "tmp%8#0" + ], + "stack_out": [ + "return_value_times%1#0", + "return_value_times%3#0", + "return_value_times%5#0", + "return_value_times%7#0", + "tmp%8#0" + ] + }, + "491": { + "op": "bytec_0 // 0x", + "stack_out": [ + "return_value_times%1#0", + "return_value_times%3#0", + "return_value_times%5#0", + "return_value_times%7#0", + "tmp%8#0", + "0x" + ] + }, + "492": { + "op": "uncover 1", + "stack_out": [ + "return_value_times%1#0", + "return_value_times%3#0", + "return_value_times%5#0", + "return_value_times%7#0", + "0x", + "tmp%8#0" + ] + }, + "494": { + "op": "concat", + "defined_out": [ + "tmp%9#1" + ], + "stack_out": [ + "return_value_times%1#0", + "return_value_times%3#0", + "return_value_times%5#0", + "return_value_times%7#0", + "tmp%9#1" + ] + }, + "495": { + "op": "bytec_1 // method \"ARC4TestStruct(uint64)\"", + "stack_out": [ + "return_value_times%1#0", + "return_value_times%3#0", + "return_value_times%5#0", + "return_value_times%7#0", + "tmp%9#1", + "Method(ARC4TestStruct(uint64))" + ] + }, + "496": { + "op": "uncover 1", + "stack_out": [ + "return_value_times%1#0", + "return_value_times%3#0", + "return_value_times%5#0", + "return_value_times%7#0", + "Method(ARC4TestStruct(uint64))", + "tmp%9#1" + ] + }, + "498": { + "op": "concat", + "defined_out": [ + "event%4#0" + ], + "stack_out": [ + "return_value_times%1#0", + "return_value_times%3#0", + "return_value_times%5#0", + "return_value_times%7#0", + "event%4#0" + ] + }, + "499": { + "op": "log", + "stack_out": [ + "return_value_times%1#0", + "return_value_times%3#0", + "return_value_times%5#0", + "return_value_times%7#0" + ] + }, + "500": { + "op": "intc_0 // 2", + "stack_out": [ + "return_value_times%1#0", + "return_value_times%3#0", + "return_value_times%5#0", + "return_value_times%7#0", + "2" + ] + }, + "501": { + "op": "itob", + "defined_out": [ + "tmp%10#1" + ], + "stack_out": [ + "return_value_times%1#0", + "return_value_times%3#0", + "return_value_times%5#0", + "return_value_times%7#0", + "tmp%10#1" + ] + }, + "502": { + "op": "bytec_0 // 0x", + "stack_out": [ + "return_value_times%1#0", + "return_value_times%3#0", + "return_value_times%5#0", + "return_value_times%7#0", + "tmp%10#1", + "0x" + ] + }, + "503": { + "op": "uncover 1", + "stack_out": [ + "return_value_times%1#0", + "return_value_times%3#0", + "return_value_times%5#0", + "return_value_times%7#0", + "0x", + "tmp%10#1" + ] + }, + "505": { + "op": "concat", + "defined_out": [ + "tmp%11#1" + ], + "stack_out": [ + "return_value_times%1#0", + "return_value_times%3#0", + "return_value_times%5#0", + "return_value_times%7#0", + "tmp%11#1" + ] + }, + "506": { + "op": "bytec_1 // method \"ARC4TestStruct(uint64)\"", + "stack_out": [ + "return_value_times%1#0", + "return_value_times%3#0", + "return_value_times%5#0", + "return_value_times%7#0", + "tmp%11#1", + "Method(ARC4TestStruct(uint64))" + ] + }, + "507": { + "op": "uncover 1", + "stack_out": [ + "return_value_times%1#0", + "return_value_times%3#0", + "return_value_times%5#0", + "return_value_times%7#0", + "Method(ARC4TestStruct(uint64))", + "tmp%11#1" + ] + }, + "509": { + "op": "concat", + "defined_out": [ + "event%5#0" + ], + "stack_out": [ + "return_value_times%1#0", + "return_value_times%3#0", + "return_value_times%5#0", + "return_value_times%7#0", + "event%5#0" + ] + }, + "510": { + "op": "log", + "stack_out": [ + "return_value_times%1#0", + "return_value_times%3#0", + "return_value_times%5#0", + "return_value_times%7#0" + ] + }, + "511": { + "op": "intc_0 // 2", + "stack_out": [ + "return_value_times%1#0", + "return_value_times%3#0", + "return_value_times%5#0", + "return_value_times%7#0", + "2" + ] + }, + "512": { + "op": "itob", + "defined_out": [ + "tmp%12#1" + ], + "stack_out": [ + "return_value_times%1#0", + "return_value_times%3#0", + "return_value_times%5#0", + "return_value_times%7#0", + "tmp%12#1" + ] + }, + "513": { + "op": "bytec_0 // 0x", + "stack_out": [ + "return_value_times%1#0", + "return_value_times%3#0", + "return_value_times%5#0", + "return_value_times%7#0", + "tmp%12#1", + "0x" + ] + }, + "514": { + "op": "uncover 1", + "stack_out": [ + "return_value_times%1#0", + "return_value_times%3#0", + "return_value_times%5#0", + "return_value_times%7#0", + "0x", + "tmp%12#1" + ] + }, + "516": { + "op": "concat", + "defined_out": [ + "tmp%13#1" + ], + "stack_out": [ + "return_value_times%1#0", + "return_value_times%3#0", + "return_value_times%5#0", + "return_value_times%7#0", + "tmp%13#1" + ] + }, + "517": { + "op": "bytec_1 // method \"ARC4TestStruct(uint64)\"", + "stack_out": [ + "return_value_times%1#0", + "return_value_times%3#0", + "return_value_times%5#0", + "return_value_times%7#0", + "tmp%13#1", + "Method(ARC4TestStruct(uint64))" + ] + }, + "518": { + "op": "uncover 1", + "stack_out": [ + "return_value_times%1#0", + "return_value_times%3#0", + "return_value_times%5#0", + "return_value_times%7#0", + "Method(ARC4TestStruct(uint64))", + "tmp%13#1" + ] + }, + "520": { + "op": "concat", + "defined_out": [ + "event%6#0" + ], + "stack_out": [ + "return_value_times%1#0", + "return_value_times%3#0", + "return_value_times%5#0", + "return_value_times%7#0", + "event%6#0" + ] + }, + "521": { + "op": "log", + "stack_out": [ + "return_value_times%1#0", + "return_value_times%3#0", + "return_value_times%5#0", + "return_value_times%7#0" + ] + }, + "522": { + "op": "intc_0 // 2", + "stack_out": [ + "return_value_times%1#0", + "return_value_times%3#0", + "return_value_times%5#0", + "return_value_times%7#0", + "2" + ] + }, + "523": { + "op": "itob", + "defined_out": [ + "tmp%14#1" + ], + "stack_out": [ + "return_value_times%1#0", + "return_value_times%3#0", + "return_value_times%5#0", + "return_value_times%7#0", + "tmp%14#1" + ] + }, + "524": { + "op": "bytec_0 // 0x", + "stack_out": [ + "return_value_times%1#0", + "return_value_times%3#0", + "return_value_times%5#0", + "return_value_times%7#0", + "tmp%14#1", + "0x" + ] + }, + "525": { + "op": "uncover 1", + "stack_out": [ + "return_value_times%1#0", + "return_value_times%3#0", + "return_value_times%5#0", + "return_value_times%7#0", + "0x", + "tmp%14#1" + ] + }, + "527": { + "op": "concat", + "defined_out": [ + "tmp%15#1" + ], + "stack_out": [ + "return_value_times%1#0", + "return_value_times%3#0", + "return_value_times%5#0", + "return_value_times%7#0", + "tmp%15#1" + ] + }, + "528": { + "op": "bytec_1 // method \"ARC4TestStruct(uint64)\"", + "stack_out": [ + "return_value_times%1#0", + "return_value_times%3#0", + "return_value_times%5#0", + "return_value_times%7#0", + "tmp%15#1", + "Method(ARC4TestStruct(uint64))" + ] + }, + "529": { + "op": "uncover 1", + "stack_out": [ + "return_value_times%1#0", + "return_value_times%3#0", + "return_value_times%5#0", + "return_value_times%7#0", + "Method(ARC4TestStruct(uint64))", + "tmp%15#1" + ] + }, + "531": { + "op": "concat", + "defined_out": [ + "event%7#0" + ], + "stack_out": [ + "return_value_times%1#0", + "return_value_times%3#0", + "return_value_times%5#0", + "return_value_times%7#0", + "event%7#0" + ] + }, + "532": { + "op": "log", + "stack_out": [ + "return_value_times%1#0", + "return_value_times%3#0", + "return_value_times%5#0", + "return_value_times%7#0" + ] + }, + "533": { + "op": "b test_cases.structure_methods.contract.TestContract.test_after_inlined_test_cases.structure_methods.contract.GroupedMethods.always_inlined_not_usually_inlined@2" + }, + "536": { + "block": "test_cases.structure_methods.contract.TestContract.test_after_inlined_test_cases.structure_methods.contract.GroupedMethods.always_inlined_not_usually_inlined@2", + "stack_in": [ + "return_value_times%1#0", + "return_value_times%3#0", + "return_value_times%5#0", + "return_value_times%7#0" + ], + "op": "b test_cases.structure_methods.contract.TestContract.test_block@3" + }, + "539": { + "block": "test_cases.structure_methods.contract.TestContract.test_block@3", + "stack_in": [ + "return_value_times%1#0", + "return_value_times%3#0", + "return_value_times%5#0", + "return_value_times%7#0" + ], + "op": "intc_0 // 2", + "defined_out": [ + "2" + ], + "stack_out": [ + "return_value_times%1#0", + "return_value_times%3#0", + "return_value_times%5#0", + "return_value_times%7#0", + "2" + ] + }, + "540": { + "op": "itob", + "defined_out": [ + "tmp%0#0" + ], + "stack_out": [ + "return_value_times%1#0", + "return_value_times%3#0", + "return_value_times%5#0", + "return_value_times%7#0", + "tmp%0#0" + ] + }, + "541": { + "op": "bytec_0 // 0x", + "defined_out": [ + "0x", + "tmp%0#0" + ], + "stack_out": [ + "return_value_times%1#0", + "return_value_times%3#0", + "return_value_times%5#0", + "return_value_times%7#0", + "tmp%0#0", + "0x" + ] + }, + "542": { + "op": "uncover 1", + "stack_out": [ + "return_value_times%1#0", + "return_value_times%3#0", + "return_value_times%5#0", + "return_value_times%7#0", + "0x", + "tmp%0#0" + ] + }, + "544": { + "op": "concat", + "defined_out": [ + "tmp%1#1" + ], + "stack_out": [ + "return_value_times%1#0", + "return_value_times%3#0", + "return_value_times%5#0", + "return_value_times%7#0", + "tmp%1#1" + ] + }, + "545": { + "op": "bytec_1 // method \"ARC4TestStruct(uint64)\"", + "defined_out": [ + "Method(ARC4TestStruct(uint64))", + "tmp%1#1" + ], + "stack_out": [ + "return_value_times%1#0", + "return_value_times%3#0", + "return_value_times%5#0", + "return_value_times%7#0", + "tmp%1#1", + "Method(ARC4TestStruct(uint64))" + ] + }, + "546": { + "op": "uncover 1", + "stack_out": [ + "return_value_times%1#0", + "return_value_times%3#0", + "return_value_times%5#0", + "return_value_times%7#0", + "Method(ARC4TestStruct(uint64))", + "tmp%1#1" + ] + }, + "548": { + "op": "concat", + "defined_out": [ + "event%0#0" + ], + "stack_out": [ + "return_value_times%1#0", + "return_value_times%3#0", + "return_value_times%5#0", + "return_value_times%7#0", + "event%0#0" + ] + }, + "549": { + "op": "log", + "stack_out": [ + "return_value_times%1#0", + "return_value_times%3#0", + "return_value_times%5#0", + "return_value_times%7#0" + ] + }, + "550": { + "op": "intc_0 // 2", + "stack_out": [ + "return_value_times%1#0", + "return_value_times%3#0", + "return_value_times%5#0", + "return_value_times%7#0", + "2" + ] + }, + "551": { + "op": "itob", + "defined_out": [ + "tmp%2#0" + ], + "stack_out": [ + "return_value_times%1#0", + "return_value_times%3#0", + "return_value_times%5#0", + "return_value_times%7#0", + "tmp%2#0" + ] + }, + "552": { + "op": "bytec_0 // 0x", + "stack_out": [ + "return_value_times%1#0", + "return_value_times%3#0", + "return_value_times%5#0", + "return_value_times%7#0", + "tmp%2#0", + "0x" + ] + }, + "553": { + "op": "uncover 1", + "stack_out": [ + "return_value_times%1#0", + "return_value_times%3#0", + "return_value_times%5#0", + "return_value_times%7#0", + "0x", + "tmp%2#0" + ] + }, + "555": { + "op": "concat", + "defined_out": [ + "tmp%3#1" + ], + "stack_out": [ + "return_value_times%1#0", + "return_value_times%3#0", + "return_value_times%5#0", + "return_value_times%7#0", + "tmp%3#1" + ] + }, + "556": { + "op": "bytec_1 // method \"ARC4TestStruct(uint64)\"", + "stack_out": [ + "return_value_times%1#0", + "return_value_times%3#0", + "return_value_times%5#0", + "return_value_times%7#0", + "tmp%3#1", + "Method(ARC4TestStruct(uint64))" + ] + }, + "557": { + "op": "uncover 1", + "stack_out": [ + "return_value_times%1#0", + "return_value_times%3#0", + "return_value_times%5#0", + "return_value_times%7#0", + "Method(ARC4TestStruct(uint64))", + "tmp%3#1" + ] + }, + "559": { + "op": "concat", + "defined_out": [ + "event%1#0" + ], + "stack_out": [ + "return_value_times%1#0", + "return_value_times%3#0", + "return_value_times%5#0", + "return_value_times%7#0", + "event%1#0" + ] + }, + "560": { + "op": "log", + "stack_out": [ + "return_value_times%1#0", + "return_value_times%3#0", + "return_value_times%5#0", + "return_value_times%7#0" + ] + }, + "561": { + "op": "intc_0 // 2", + "stack_out": [ + "return_value_times%1#0", + "return_value_times%3#0", + "return_value_times%5#0", + "return_value_times%7#0", + "2" + ] + }, + "562": { + "op": "itob", + "defined_out": [ + "tmp%4#1" + ], + "stack_out": [ + "return_value_times%1#0", + "return_value_times%3#0", + "return_value_times%5#0", + "return_value_times%7#0", + "tmp%4#1" + ] + }, + "563": { + "op": "bytec_0 // 0x", + "stack_out": [ + "return_value_times%1#0", + "return_value_times%3#0", + "return_value_times%5#0", + "return_value_times%7#0", + "tmp%4#1", + "0x" + ] + }, + "564": { + "op": "uncover 1", + "stack_out": [ + "return_value_times%1#0", + "return_value_times%3#0", + "return_value_times%5#0", + "return_value_times%7#0", + "0x", + "tmp%4#1" + ] + }, + "566": { + "op": "concat", + "defined_out": [ + "tmp%5#1" + ], + "stack_out": [ + "return_value_times%1#0", + "return_value_times%3#0", + "return_value_times%5#0", + "return_value_times%7#0", + "tmp%5#1" + ] + }, + "567": { + "op": "bytec_1 // method \"ARC4TestStruct(uint64)\"", + "stack_out": [ + "return_value_times%1#0", + "return_value_times%3#0", + "return_value_times%5#0", + "return_value_times%7#0", + "tmp%5#1", + "Method(ARC4TestStruct(uint64))" + ] + }, + "568": { + "op": "uncover 1", + "stack_out": [ + "return_value_times%1#0", + "return_value_times%3#0", + "return_value_times%5#0", + "return_value_times%7#0", + "Method(ARC4TestStruct(uint64))", + "tmp%5#1" + ] + }, + "570": { + "op": "concat", + "defined_out": [ + "event%2#0" + ], + "stack_out": [ + "return_value_times%1#0", + "return_value_times%3#0", + "return_value_times%5#0", + "return_value_times%7#0", + "event%2#0" + ] + }, + "571": { + "op": "log", + "stack_out": [ + "return_value_times%1#0", + "return_value_times%3#0", + "return_value_times%5#0", + "return_value_times%7#0" + ] + }, + "572": { + "op": "intc_0 // 2", + "stack_out": [ + "return_value_times%1#0", + "return_value_times%3#0", + "return_value_times%5#0", + "return_value_times%7#0", + "2" + ] + }, + "573": { + "op": "itob", + "defined_out": [ + "tmp%6#0" + ], + "stack_out": [ + "return_value_times%1#0", + "return_value_times%3#0", + "return_value_times%5#0", + "return_value_times%7#0", + "tmp%6#0" + ] + }, + "574": { + "op": "bytec_0 // 0x", + "stack_out": [ + "return_value_times%1#0", + "return_value_times%3#0", + "return_value_times%5#0", + "return_value_times%7#0", + "tmp%6#0", + "0x" + ] + }, + "575": { + "op": "uncover 1", + "stack_out": [ + "return_value_times%1#0", + "return_value_times%3#0", + "return_value_times%5#0", + "return_value_times%7#0", + "0x", + "tmp%6#0" + ] + }, + "577": { + "op": "concat", + "defined_out": [ + "tmp%7#1" + ], + "stack_out": [ + "return_value_times%1#0", + "return_value_times%3#0", + "return_value_times%5#0", + "return_value_times%7#0", + "tmp%7#1" + ] + }, + "578": { + "op": "bytec_1 // method \"ARC4TestStruct(uint64)\"", + "stack_out": [ + "return_value_times%1#0", + "return_value_times%3#0", + "return_value_times%5#0", + "return_value_times%7#0", + "tmp%7#1", + "Method(ARC4TestStruct(uint64))" + ] + }, + "579": { + "op": "uncover 1", + "stack_out": [ + "return_value_times%1#0", + "return_value_times%3#0", + "return_value_times%5#0", + "return_value_times%7#0", + "Method(ARC4TestStruct(uint64))", + "tmp%7#1" + ] + }, + "581": { + "op": "concat", + "defined_out": [ + "event%3#0" + ], + "stack_out": [ + "return_value_times%1#0", + "return_value_times%3#0", + "return_value_times%5#0", + "return_value_times%7#0", + "event%3#0" + ] + }, + "582": { + "op": "log", + "stack_out": [ + "return_value_times%1#0", + "return_value_times%3#0", + "return_value_times%5#0", + "return_value_times%7#0" + ] + }, + "583": { + "op": "intc_0 // 2", + "stack_out": [ + "return_value_times%1#0", + "return_value_times%3#0", + "return_value_times%5#0", + "return_value_times%7#0", + "2" + ] + }, + "584": { + "op": "itob", + "defined_out": [ + "tmp%8#0" + ], + "stack_out": [ + "return_value_times%1#0", + "return_value_times%3#0", + "return_value_times%5#0", + "return_value_times%7#0", + "tmp%8#0" + ] + }, + "585": { + "op": "bytec_0 // 0x", + "stack_out": [ + "return_value_times%1#0", + "return_value_times%3#0", + "return_value_times%5#0", + "return_value_times%7#0", + "tmp%8#0", + "0x" + ] + }, + "586": { + "op": "uncover 1", + "stack_out": [ + "return_value_times%1#0", + "return_value_times%3#0", + "return_value_times%5#0", + "return_value_times%7#0", + "0x", + "tmp%8#0" + ] + }, + "588": { + "op": "concat", + "defined_out": [ + "tmp%9#1" + ], + "stack_out": [ + "return_value_times%1#0", + "return_value_times%3#0", + "return_value_times%5#0", + "return_value_times%7#0", + "tmp%9#1" + ] + }, + "589": { + "op": "bytec_1 // method \"ARC4TestStruct(uint64)\"", + "stack_out": [ + "return_value_times%1#0", + "return_value_times%3#0", + "return_value_times%5#0", + "return_value_times%7#0", + "tmp%9#1", + "Method(ARC4TestStruct(uint64))" + ] + }, + "590": { + "op": "uncover 1", + "stack_out": [ + "return_value_times%1#0", + "return_value_times%3#0", + "return_value_times%5#0", + "return_value_times%7#0", + "Method(ARC4TestStruct(uint64))", + "tmp%9#1" + ] + }, + "592": { + "op": "concat", + "defined_out": [ + "event%4#0" + ], + "stack_out": [ + "return_value_times%1#0", + "return_value_times%3#0", + "return_value_times%5#0", + "return_value_times%7#0", + "event%4#0" + ] + }, + "593": { + "op": "log", + "stack_out": [ + "return_value_times%1#0", + "return_value_times%3#0", + "return_value_times%5#0", + "return_value_times%7#0" + ] + }, + "594": { + "op": "intc_0 // 2", + "stack_out": [ + "return_value_times%1#0", + "return_value_times%3#0", + "return_value_times%5#0", + "return_value_times%7#0", + "2" + ] + }, + "595": { + "op": "itob", + "defined_out": [ + "tmp%10#1" + ], + "stack_out": [ + "return_value_times%1#0", + "return_value_times%3#0", + "return_value_times%5#0", + "return_value_times%7#0", + "tmp%10#1" + ] + }, + "596": { + "op": "bytec_0 // 0x", + "stack_out": [ + "return_value_times%1#0", + "return_value_times%3#0", + "return_value_times%5#0", + "return_value_times%7#0", + "tmp%10#1", + "0x" + ] + }, + "597": { + "op": "uncover 1", + "stack_out": [ + "return_value_times%1#0", + "return_value_times%3#0", + "return_value_times%5#0", + "return_value_times%7#0", + "0x", + "tmp%10#1" + ] + }, + "599": { + "op": "concat", + "defined_out": [ + "tmp%11#1" + ], + "stack_out": [ + "return_value_times%1#0", + "return_value_times%3#0", + "return_value_times%5#0", + "return_value_times%7#0", + "tmp%11#1" + ] + }, + "600": { + "op": "bytec_1 // method \"ARC4TestStruct(uint64)\"", + "stack_out": [ + "return_value_times%1#0", + "return_value_times%3#0", + "return_value_times%5#0", + "return_value_times%7#0", + "tmp%11#1", + "Method(ARC4TestStruct(uint64))" + ] + }, + "601": { + "op": "uncover 1", + "stack_out": [ + "return_value_times%1#0", + "return_value_times%3#0", + "return_value_times%5#0", + "return_value_times%7#0", + "Method(ARC4TestStruct(uint64))", + "tmp%11#1" + ] + }, + "603": { + "op": "concat", + "defined_out": [ + "event%5#0" + ], + "stack_out": [ + "return_value_times%1#0", + "return_value_times%3#0", + "return_value_times%5#0", + "return_value_times%7#0", + "event%5#0" + ] + }, + "604": { + "op": "log", + "stack_out": [ + "return_value_times%1#0", + "return_value_times%3#0", + "return_value_times%5#0", + "return_value_times%7#0" + ] + }, + "605": { + "op": "intc_0 // 2", + "stack_out": [ + "return_value_times%1#0", + "return_value_times%3#0", + "return_value_times%5#0", + "return_value_times%7#0", + "2" + ] + }, + "606": { + "op": "itob", + "defined_out": [ + "tmp%12#1" + ], + "stack_out": [ + "return_value_times%1#0", + "return_value_times%3#0", + "return_value_times%5#0", + "return_value_times%7#0", + "tmp%12#1" + ] + }, + "607": { + "op": "bytec_0 // 0x", + "stack_out": [ + "return_value_times%1#0", + "return_value_times%3#0", + "return_value_times%5#0", + "return_value_times%7#0", + "tmp%12#1", + "0x" + ] + }, + "608": { + "op": "uncover 1", + "stack_out": [ + "return_value_times%1#0", + "return_value_times%3#0", + "return_value_times%5#0", + "return_value_times%7#0", + "0x", + "tmp%12#1" + ] + }, + "610": { + "op": "concat", + "defined_out": [ + "tmp%13#1" + ], + "stack_out": [ + "return_value_times%1#0", + "return_value_times%3#0", + "return_value_times%5#0", + "return_value_times%7#0", + "tmp%13#1" + ] + }, + "611": { + "op": "bytec_1 // method \"ARC4TestStruct(uint64)\"", + "stack_out": [ + "return_value_times%1#0", + "return_value_times%3#0", + "return_value_times%5#0", + "return_value_times%7#0", + "tmp%13#1", + "Method(ARC4TestStruct(uint64))" + ] + }, + "612": { + "op": "uncover 1", + "stack_out": [ + "return_value_times%1#0", + "return_value_times%3#0", + "return_value_times%5#0", + "return_value_times%7#0", + "Method(ARC4TestStruct(uint64))", + "tmp%13#1" + ] + }, + "614": { + "op": "concat", + "defined_out": [ + "event%6#0" + ], + "stack_out": [ + "return_value_times%1#0", + "return_value_times%3#0", + "return_value_times%5#0", + "return_value_times%7#0", + "event%6#0" + ] + }, + "615": { + "op": "log", + "stack_out": [ + "return_value_times%1#0", + "return_value_times%3#0", + "return_value_times%5#0", + "return_value_times%7#0" + ] + }, + "616": { + "op": "intc_0 // 2", + "stack_out": [ + "return_value_times%1#0", + "return_value_times%3#0", + "return_value_times%5#0", + "return_value_times%7#0", + "2" + ] + }, + "617": { + "op": "itob", + "defined_out": [ + "tmp%14#1" + ], + "stack_out": [ + "return_value_times%1#0", + "return_value_times%3#0", + "return_value_times%5#0", + "return_value_times%7#0", + "tmp%14#1" + ] + }, + "618": { + "op": "bytec_0 // 0x", + "stack_out": [ + "return_value_times%1#0", + "return_value_times%3#0", + "return_value_times%5#0", + "return_value_times%7#0", + "tmp%14#1", + "0x" + ] + }, + "619": { + "op": "uncover 1", + "stack_out": [ + "return_value_times%1#0", + "return_value_times%3#0", + "return_value_times%5#0", + "return_value_times%7#0", + "0x", + "tmp%14#1" + ] + }, + "621": { + "op": "concat", + "defined_out": [ + "tmp%15#1" + ], + "stack_out": [ + "return_value_times%1#0", + "return_value_times%3#0", + "return_value_times%5#0", + "return_value_times%7#0", + "tmp%15#1" + ] + }, + "622": { + "op": "bytec_1 // method \"ARC4TestStruct(uint64)\"", + "stack_out": [ + "return_value_times%1#0", + "return_value_times%3#0", + "return_value_times%5#0", + "return_value_times%7#0", + "tmp%15#1", + "Method(ARC4TestStruct(uint64))" + ] + }, + "623": { + "op": "uncover 1", + "stack_out": [ + "return_value_times%1#0", + "return_value_times%3#0", + "return_value_times%5#0", + "return_value_times%7#0", + "Method(ARC4TestStruct(uint64))", + "tmp%15#1" + ] + }, + "625": { + "op": "concat", + "defined_out": [ + "event%7#0" + ], + "stack_out": [ + "return_value_times%1#0", + "return_value_times%3#0", + "return_value_times%5#0", + "return_value_times%7#0", + "event%7#0" + ] + }, + "626": { + "op": "log", + "stack_out": [ + "return_value_times%1#0", + "return_value_times%3#0", + "return_value_times%5#0", + "return_value_times%7#0" + ] + }, + "627": { + "op": "b test_cases.structure_methods.contract.TestContract.test_after_inlined_test_cases.structure_methods.contract.GroupedMethods.always_inlined_not_usually_inlined@4" + }, + "630": { + "block": "test_cases.structure_methods.contract.TestContract.test_after_inlined_test_cases.structure_methods.contract.GroupedMethods.always_inlined_not_usually_inlined@4", + "stack_in": [ + "return_value_times%1#0", + "return_value_times%3#0", + "return_value_times%5#0", + "return_value_times%7#0" + ], + "op": "intc_0 // 2", + "defined_out": [ + "2" + ], + "stack_out": [ + "return_value_times%1#0", + "return_value_times%3#0", + "return_value_times%5#0", + "return_value_times%7#0", + "2" + ] + }, + "631": { + "callsub": "test_cases.structure_methods.contract.GroupedMethods.not_usually_inlined", + "op": "callsub not_usually_inlined", + "stack_out": [ + "return_value_times%1#0", + "return_value_times%3#0", + "return_value_times%5#0", + "return_value_times%7#0" + ] + }, + "634": { + "op": "intc_0 // 2", + "stack_out": [ + "return_value_times%1#0", + "return_value_times%3#0", + "return_value_times%5#0", + "return_value_times%7#0", + "2" + ] + }, + "635": { + "callsub": "test_cases.structure_methods.contract.GroupedMethods.not_usually_inlined", + "op": "callsub not_usually_inlined", + "stack_out": [ + "return_value_times%1#0", + "return_value_times%3#0", + "return_value_times%5#0", + "return_value_times%7#0" + ] + }, + "638": { + "retsub": true, + "op": "retsub" + } + } +} \ No newline at end of file diff --git a/test_cases/structure_methods/out_unoptimized/TestContract.approval.stats.txt b/test_cases/structure_methods/out_unoptimized/TestContract.approval.stats.txt new file mode 100644 index 0000000000..64ce56a15d --- /dev/null +++ b/test_cases/structure_methods/out_unoptimized/TestContract.approval.stats.txt @@ -0,0 +1,10 @@ +total_bytes = 639 +total_ops = 417 +constant_bytes = 157 +constant_ops = 121 +control_flow_bytes = 136 +control_flow_ops = 45 +stack_bytes = 146 +stack_ops = 73 +other_bytes = 199 +other_ops = 178 \ No newline at end of file diff --git a/test_cases/structure_methods/out_unoptimized/TestContract.approval.teal b/test_cases/structure_methods/out_unoptimized/TestContract.approval.teal new file mode 100644 index 0000000000..6a8ed5e8be --- /dev/null +++ b/test_cases/structure_methods/out_unoptimized/TestContract.approval.teal @@ -0,0 +1,711 @@ +#pragma version 11 +#pragma typetrack false + +// algopy.arc4.ARC4Contract.approval_program() -> uint64: +main: + intcblock 2 1 0 18 + bytecblock 0x 0xed3267e8 0x0000000000000009 + b main_block@0 + +main_block@0: + b main_block@1 + +main_block@1: + // structure_methods/contract.py:69 + // class TestContract(ARC4Contract): + txn NumAppArgs + intc_2 // 0 + != + bz main___algopy_default_create@5 + b main_abi_routing@2 + +main_abi_routing@2: + // structure_methods/contract.py:69 + // class TestContract(ARC4Contract): + txna ApplicationArgs 0 + pushbytes 0xa78000de // method "test()void" + uncover 1 + match main_test_route@3 + b main_switch_case_next@4 + +main_switch_case_next@4: + b main_after_if_else@6 + +main_after_if_else@6: + // structure_methods/contract.py:69 + // class TestContract(ARC4Contract): + err + +main_test_route@3: + // structure_methods/contract.py:70 + // @public + txn OnCompletion + intc_2 // NoOp + == + txn ApplicationID + intc_2 // 0 + != + && + assert + callsub test + b main_switch_case_next@4 + +main___algopy_default_create@5: + txn OnCompletion + intc_2 // NoOp + == + txn ApplicationID + intc_2 // 0 + == + && + assert + b main_block@8 + +main_block@8: + b main_after_inlined_test_cases.structure_methods.contract.TestContract.__algopy_default_create@9 + +main_after_inlined_test_cases.structure_methods.contract.TestContract.__algopy_default_create@9: + intc_1 // 1 + return + + +// test_cases.structure_methods.contract.ARC4TestStruct.return_value_times(self: bytes, times: uint64) -> uint64, bytes: +return_value_times: + // structure_methods/contract.py:9 + // def return_value_times(self, times: UInt64) -> UInt64: + proto 2 2 + b return_value_times_block@0 + +return_value_times_block@0: + // structure_methods/contract.py:10 + // return self.value.as_uint64() * times + frame_dig -2 + intc_2 // 0 + pushint 8 + extract3 + btoi + frame_dig -1 + * + frame_dig -2 + retsub + + +// test_cases.structure_methods.contract.ARC4TestStruct.return1() -> uint64: +return1: + b return1_block@0 + +return1_block@0: + // structure_methods/contract.py:14 + // return UInt64(1) + intc_1 // 1 + retsub + + +// test_cases.structure_methods.contract.TestStruct.return_value_times(self: bytes, times: uint64) -> uint64, bytes: +test_cases.structure_methods.contract.TestStruct.return_value_times: + // structure_methods/contract.py:20 + // def return_value_times(self, times: UInt64) -> UInt64: + proto 2 2 + b test_cases.structure_methods.contract.TestStruct.return_value_times_block@0 + +test_cases.structure_methods.contract.TestStruct.return_value_times_block@0: + // structure_methods/contract.py:21 + // return self.value * times + frame_dig -2 + intc_2 // 0 + pushint 8 + extract3 + btoi + frame_dig -1 + * + frame_dig -2 + retsub + + +// test_cases.structure_methods.contract.TestStruct.return1() -> uint64: +test_cases.structure_methods.contract.TestStruct.return1: + b test_cases.structure_methods.contract.TestStruct.return1_block@0 + +test_cases.structure_methods.contract.TestStruct.return1_block@0: + // structure_methods/contract.py:25 + // return UInt64(1) + intc_1 // 1 + retsub + + +// test_cases.structure_methods.contract.TestNamedTuple.return_value_times(self.value: uint64, times: uint64) -> uint64: +test_cases.structure_methods.contract.TestNamedTuple.return_value_times: + // structure_methods/contract.py:31 + // def return_value_times(self, times: UInt64) -> UInt64: + proto 2 1 + b test_cases.structure_methods.contract.TestNamedTuple.return_value_times_block@0 + +test_cases.structure_methods.contract.TestNamedTuple.return_value_times_block@0: + // structure_methods/contract.py:32 + // return self.value * times + frame_dig -2 + frame_dig -1 + * + retsub + + +// test_cases.structure_methods.contract.TestNamedTuple.return1() -> uint64: +test_cases.structure_methods.contract.TestNamedTuple.return1: + b test_cases.structure_methods.contract.TestNamedTuple.return1_block@0 + +test_cases.structure_methods.contract.TestNamedTuple.return1_block@0: + // structure_methods/contract.py:36 + // return UInt64(1) + intc_1 // 1 + retsub + + +// test_cases.structure_methods.contract.GroupedMethods.never_inlined_usually_inlined(v: uint64) -> uint64: +never_inlined_usually_inlined: + // structure_methods/contract.py:40-41 + // @subroutine(inline=False) + // def never_inlined_usually_inlined(self, v: UInt64) -> UInt64: + proto 1 1 + b never_inlined_usually_inlined_block@0 + +never_inlined_usually_inlined_block@0: + // structure_methods/contract.py:42 + // return v + UInt64(1) + frame_dig -1 + intc_1 // 1 + + + retsub + + +// test_cases.structure_methods.contract.GroupedMethods.usually_inlined(v: uint64) -> uint64: +usually_inlined: + // structure_methods/contract.py:55 + // def usually_inlined(self, v: UInt64) -> UInt64: + proto 1 1 + b usually_inlined_block@0 + +usually_inlined_block@0: + // structure_methods/contract.py:56 + // return v + UInt64(1) + frame_dig -1 + intc_1 // 1 + + + retsub + + +// test_cases.structure_methods.contract.GroupedMethods.not_usually_inlined(v: uint64) -> void: +not_usually_inlined: + // structure_methods/contract.py:58 + // def not_usually_inlined(self, v: UInt64) -> None: + proto 1 0 + b not_usually_inlined_block@0 + +not_usually_inlined_block@0: + // structure_methods/contract.py:59 + // arc4.emit(ARC4TestStruct(arc4.UInt64(v))) + frame_dig -1 + itob + bytec_0 // 0x + uncover 1 + concat + bytec_1 // method "ARC4TestStruct(uint64)" + uncover 1 + concat + log + // structure_methods/contract.py:60 + // arc4.emit(ARC4TestStruct(arc4.UInt64(v))) + frame_dig -1 + itob + bytec_0 // 0x + uncover 1 + concat + bytec_1 // method "ARC4TestStruct(uint64)" + uncover 1 + concat + log + // structure_methods/contract.py:61 + // arc4.emit(ARC4TestStruct(arc4.UInt64(v))) + frame_dig -1 + itob + bytec_0 // 0x + uncover 1 + concat + bytec_1 // method "ARC4TestStruct(uint64)" + uncover 1 + concat + log + // structure_methods/contract.py:62 + // arc4.emit(ARC4TestStruct(arc4.UInt64(v))) + frame_dig -1 + itob + bytec_0 // 0x + uncover 1 + concat + bytec_1 // method "ARC4TestStruct(uint64)" + uncover 1 + concat + log + // structure_methods/contract.py:63 + // arc4.emit(ARC4TestStruct(arc4.UInt64(v))) + frame_dig -1 + itob + bytec_0 // 0x + uncover 1 + concat + bytec_1 // method "ARC4TestStruct(uint64)" + uncover 1 + concat + log + // structure_methods/contract.py:64 + // arc4.emit(ARC4TestStruct(arc4.UInt64(v))) + frame_dig -1 + itob + bytec_0 // 0x + uncover 1 + concat + bytec_1 // method "ARC4TestStruct(uint64)" + uncover 1 + concat + log + // structure_methods/contract.py:65 + // arc4.emit(ARC4TestStruct(arc4.UInt64(v))) + frame_dig -1 + itob + bytec_0 // 0x + uncover 1 + concat + bytec_1 // method "ARC4TestStruct(uint64)" + uncover 1 + concat + log + // structure_methods/contract.py:66 + // arc4.emit(ARC4TestStruct(arc4.UInt64(v))) + frame_dig -1 + itob + bytec_0 // 0x + uncover 1 + concat + bytec_1 // method "ARC4TestStruct(uint64)" + uncover 1 + concat + log + retsub + + +// test_cases.structure_methods.contract.TestContract.test[routing]() -> void: +test: + b test_block@0 + +test_block@0: + // structure_methods/contract.py:70 + // @public + callsub test_cases.structure_methods.contract.TestContract.test + intc_1 // 1 + return + + +// test_cases.structure_methods.contract.TestContract.test() -> void: +test_cases.structure_methods.contract.TestContract.test: + // structure_methods/contract.py:70-71 + // @public + // def test(self) -> None: + proto 0 0 + b test_cases.structure_methods.contract.TestContract.test_block@0 + +test_cases.structure_methods.contract.TestContract.test_block@0: + // structure_methods/contract.py:72-73 + // # Call instance methods from instance side + // assert UInt64(18) == ARC4TestStruct(arc4.UInt64(9)).return_value_times(UInt64(2)) + bytec_0 // 0x + bytec_2 // 0x0000000000000009 + concat + intc_0 // 2 + callsub return_value_times + cover 1 + intc_3 // 18 + == + assert + // structure_methods/contract.py:74 + // assert UInt64(18) == TestStruct(UInt64(9)).return_value_times(UInt64(2)) + pushint 9 + itob + bytec_0 // 0x + uncover 1 + concat + intc_0 // 2 + callsub test_cases.structure_methods.contract.TestStruct.return_value_times + cover 1 + intc_3 // 18 + == + assert + // structure_methods/contract.py:75 + // assert UInt64(18) == TestNamedTuple(UInt64(9)).return_value_times(UInt64(2)) + pushint 9 + intc_0 // 2 + callsub test_cases.structure_methods.contract.TestNamedTuple.return_value_times + intc_3 // 18 + == + assert + // structure_methods/contract.py:79 + // ARC4TestStruct(arc4.UInt64(9)), UInt64(2) + bytec_0 // 0x + bytec_2 // 0x0000000000000009 + concat + intc_0 // 2 + // structure_methods/contract.py:77-80 + // # Call instance methods from class side + // assert UInt64(18) == ARC4TestStruct.return_value_times( + // ARC4TestStruct(arc4.UInt64(9)), UInt64(2) + // ) + callsub return_value_times + cover 1 + // structure_methods/contract.py:77-78 + // # Call instance methods from class side + // assert UInt64(18) == ARC4TestStruct.return_value_times( + intc_3 // 18 + // structure_methods/contract.py:77-80 + // # Call instance methods from class side + // assert UInt64(18) == ARC4TestStruct.return_value_times( + // ARC4TestStruct(arc4.UInt64(9)), UInt64(2) + // ) + == + assert + // structure_methods/contract.py:81 + // assert UInt64(18) == TestStruct.return_value_times(TestStruct(UInt64(9)), UInt64(2)) + pushint 9 + itob + bytec_0 // 0x + uncover 1 + concat + intc_0 // 2 + callsub test_cases.structure_methods.contract.TestStruct.return_value_times + cover 1 + intc_3 // 18 + == + assert + // structure_methods/contract.py:83 + // TestNamedTuple(UInt64(9)), UInt64(2) + pushint 9 + intc_0 // 2 + // structure_methods/contract.py:82-84 + // assert UInt64(18) == TestNamedTuple.return_value_times( + // TestNamedTuple(UInt64(9)), UInt64(2) + // ) + callsub test_cases.structure_methods.contract.TestNamedTuple.return_value_times + // structure_methods/contract.py:82 + // assert UInt64(18) == TestNamedTuple.return_value_times( + intc_3 // 18 + // structure_methods/contract.py:82-84 + // assert UInt64(18) == TestNamedTuple.return_value_times( + // TestNamedTuple(UInt64(9)), UInt64(2) + // ) + == + assert + // structure_methods/contract.py:86-87 + // # Call static methods from class side + // assert UInt64(1) == ARC4TestStruct.return1() + callsub return1 + intc_1 // 1 + == + assert + // structure_methods/contract.py:88 + // assert UInt64(1) == TestStruct.return1() + callsub test_cases.structure_methods.contract.TestStruct.return1 + intc_1 // 1 + == + assert + // structure_methods/contract.py:89 + // assert UInt64(1) == TestNamedTuple.return1() + callsub test_cases.structure_methods.contract.TestNamedTuple.return1 + intc_1 // 1 + == + assert + // structure_methods/contract.py:91-92 + // # Call static methods from instance side + // assert UInt64(1) == ARC4TestStruct(arc4.UInt64(0)).return1() + callsub return1 + intc_1 // 1 + == + assert + // structure_methods/contract.py:93 + // assert UInt64(1) == TestStruct(UInt64(0)).return1() + callsub test_cases.structure_methods.contract.TestStruct.return1 + intc_1 // 1 + == + assert + // structure_methods/contract.py:94 + // assert UInt64(1) == TestNamedTuple(UInt64(0)).return1() + callsub test_cases.structure_methods.contract.TestNamedTuple.return1 + intc_1 // 1 + == + assert + // structure_methods/contract.py:96-101 + // # Every method is called twice for a simple reason: if a method is only called once it + // # makes no sense to emit it separately (doing that adds callsub/proto/retsub machinery and + // # limits the ability of our optimizer). + // # Calling a method twice forces the optimizer to decide if the contract-size wins outweigh + // # the function-calling ceremony. + // assert UInt64(3) == GroupedMethods().never_inlined_usually_inlined(UInt64(2)) + intc_0 // 2 + callsub never_inlined_usually_inlined + pushint 3 + == + assert + // structure_methods/contract.py:102 + // assert UInt64(3) == GroupedMethods().never_inlined_usually_inlined(UInt64(2)) + intc_0 // 2 + callsub never_inlined_usually_inlined + pushint 3 + == + assert + // structure_methods/contract.py:103 + // assert UInt64(3) == GroupedMethods().usually_inlined(UInt64(2)) + intc_0 // 2 + callsub usually_inlined + pushint 3 + == + assert + // structure_methods/contract.py:104 + // assert UInt64(3) == GroupedMethods().usually_inlined(UInt64(2)) + intc_0 // 2 + callsub usually_inlined + pushint 3 + == + assert + // structure_methods/contract.py:105 + // GroupedMethods().always_inlined_not_usually_inlined(UInt64(2)) + b test_cases.structure_methods.contract.TestContract.test_block@1 + +test_cases.structure_methods.contract.TestContract.test_block@1: + // structure_methods/contract.py:105 + // GroupedMethods().always_inlined_not_usually_inlined(UInt64(2)) + intc_0 // 2 + // structure_methods/contract.py:46 + // arc4.emit(ARC4TestStruct(arc4.UInt64(v))) + itob + bytec_0 // 0x + uncover 1 + concat + bytec_1 // method "ARC4TestStruct(uint64)" + uncover 1 + concat + log + // structure_methods/contract.py:105 + // GroupedMethods().always_inlined_not_usually_inlined(UInt64(2)) + intc_0 // 2 + // structure_methods/contract.py:47 + // arc4.emit(ARC4TestStruct(arc4.UInt64(v))) + itob + bytec_0 // 0x + uncover 1 + concat + bytec_1 // method "ARC4TestStruct(uint64)" + uncover 1 + concat + log + // structure_methods/contract.py:105 + // GroupedMethods().always_inlined_not_usually_inlined(UInt64(2)) + intc_0 // 2 + // structure_methods/contract.py:48 + // arc4.emit(ARC4TestStruct(arc4.UInt64(v))) + itob + bytec_0 // 0x + uncover 1 + concat + bytec_1 // method "ARC4TestStruct(uint64)" + uncover 1 + concat + log + // structure_methods/contract.py:105 + // GroupedMethods().always_inlined_not_usually_inlined(UInt64(2)) + intc_0 // 2 + // structure_methods/contract.py:49 + // arc4.emit(ARC4TestStruct(arc4.UInt64(v))) + itob + bytec_0 // 0x + uncover 1 + concat + bytec_1 // method "ARC4TestStruct(uint64)" + uncover 1 + concat + log + // structure_methods/contract.py:105 + // GroupedMethods().always_inlined_not_usually_inlined(UInt64(2)) + intc_0 // 2 + // structure_methods/contract.py:50 + // arc4.emit(ARC4TestStruct(arc4.UInt64(v))) + itob + bytec_0 // 0x + uncover 1 + concat + bytec_1 // method "ARC4TestStruct(uint64)" + uncover 1 + concat + log + // structure_methods/contract.py:105 + // GroupedMethods().always_inlined_not_usually_inlined(UInt64(2)) + intc_0 // 2 + // structure_methods/contract.py:51 + // arc4.emit(ARC4TestStruct(arc4.UInt64(v))) + itob + bytec_0 // 0x + uncover 1 + concat + bytec_1 // method "ARC4TestStruct(uint64)" + uncover 1 + concat + log + // structure_methods/contract.py:105 + // GroupedMethods().always_inlined_not_usually_inlined(UInt64(2)) + intc_0 // 2 + // structure_methods/contract.py:52 + // arc4.emit(ARC4TestStruct(arc4.UInt64(v))) + itob + bytec_0 // 0x + uncover 1 + concat + bytec_1 // method "ARC4TestStruct(uint64)" + uncover 1 + concat + log + // structure_methods/contract.py:105 + // GroupedMethods().always_inlined_not_usually_inlined(UInt64(2)) + intc_0 // 2 + // structure_methods/contract.py:53 + // arc4.emit(ARC4TestStruct(arc4.UInt64(v))) + itob + bytec_0 // 0x + uncover 1 + concat + bytec_1 // method "ARC4TestStruct(uint64)" + uncover 1 + concat + log + // structure_methods/contract.py:105 + // GroupedMethods().always_inlined_not_usually_inlined(UInt64(2)) + b test_cases.structure_methods.contract.TestContract.test_after_inlined_test_cases.structure_methods.contract.GroupedMethods.always_inlined_not_usually_inlined@2 + +test_cases.structure_methods.contract.TestContract.test_after_inlined_test_cases.structure_methods.contract.GroupedMethods.always_inlined_not_usually_inlined@2: + // structure_methods/contract.py:106 + // GroupedMethods().always_inlined_not_usually_inlined(UInt64(2)) + b test_cases.structure_methods.contract.TestContract.test_block@3 + +test_cases.structure_methods.contract.TestContract.test_block@3: + // structure_methods/contract.py:106 + // GroupedMethods().always_inlined_not_usually_inlined(UInt64(2)) + intc_0 // 2 + // structure_methods/contract.py:46 + // arc4.emit(ARC4TestStruct(arc4.UInt64(v))) + itob + bytec_0 // 0x + uncover 1 + concat + bytec_1 // method "ARC4TestStruct(uint64)" + uncover 1 + concat + log + // structure_methods/contract.py:106 + // GroupedMethods().always_inlined_not_usually_inlined(UInt64(2)) + intc_0 // 2 + // structure_methods/contract.py:47 + // arc4.emit(ARC4TestStruct(arc4.UInt64(v))) + itob + bytec_0 // 0x + uncover 1 + concat + bytec_1 // method "ARC4TestStruct(uint64)" + uncover 1 + concat + log + // structure_methods/contract.py:106 + // GroupedMethods().always_inlined_not_usually_inlined(UInt64(2)) + intc_0 // 2 + // structure_methods/contract.py:48 + // arc4.emit(ARC4TestStruct(arc4.UInt64(v))) + itob + bytec_0 // 0x + uncover 1 + concat + bytec_1 // method "ARC4TestStruct(uint64)" + uncover 1 + concat + log + // structure_methods/contract.py:106 + // GroupedMethods().always_inlined_not_usually_inlined(UInt64(2)) + intc_0 // 2 + // structure_methods/contract.py:49 + // arc4.emit(ARC4TestStruct(arc4.UInt64(v))) + itob + bytec_0 // 0x + uncover 1 + concat + bytec_1 // method "ARC4TestStruct(uint64)" + uncover 1 + concat + log + // structure_methods/contract.py:106 + // GroupedMethods().always_inlined_not_usually_inlined(UInt64(2)) + intc_0 // 2 + // structure_methods/contract.py:50 + // arc4.emit(ARC4TestStruct(arc4.UInt64(v))) + itob + bytec_0 // 0x + uncover 1 + concat + bytec_1 // method "ARC4TestStruct(uint64)" + uncover 1 + concat + log + // structure_methods/contract.py:106 + // GroupedMethods().always_inlined_not_usually_inlined(UInt64(2)) + intc_0 // 2 + // structure_methods/contract.py:51 + // arc4.emit(ARC4TestStruct(arc4.UInt64(v))) + itob + bytec_0 // 0x + uncover 1 + concat + bytec_1 // method "ARC4TestStruct(uint64)" + uncover 1 + concat + log + // structure_methods/contract.py:106 + // GroupedMethods().always_inlined_not_usually_inlined(UInt64(2)) + intc_0 // 2 + // structure_methods/contract.py:52 + // arc4.emit(ARC4TestStruct(arc4.UInt64(v))) + itob + bytec_0 // 0x + uncover 1 + concat + bytec_1 // method "ARC4TestStruct(uint64)" + uncover 1 + concat + log + // structure_methods/contract.py:106 + // GroupedMethods().always_inlined_not_usually_inlined(UInt64(2)) + intc_0 // 2 + // structure_methods/contract.py:53 + // arc4.emit(ARC4TestStruct(arc4.UInt64(v))) + itob + bytec_0 // 0x + uncover 1 + concat + bytec_1 // method "ARC4TestStruct(uint64)" + uncover 1 + concat + log + // structure_methods/contract.py:106 + // GroupedMethods().always_inlined_not_usually_inlined(UInt64(2)) + b test_cases.structure_methods.contract.TestContract.test_after_inlined_test_cases.structure_methods.contract.GroupedMethods.always_inlined_not_usually_inlined@4 + +test_cases.structure_methods.contract.TestContract.test_after_inlined_test_cases.structure_methods.contract.GroupedMethods.always_inlined_not_usually_inlined@4: + // structure_methods/contract.py:107 + // GroupedMethods().not_usually_inlined(UInt64(2)) + intc_0 // 2 + callsub not_usually_inlined + // structure_methods/contract.py:108 + // GroupedMethods().not_usually_inlined(UInt64(2)) + intc_0 // 2 + callsub not_usually_inlined + retsub diff --git a/test_cases/structure_methods/out_unoptimized/TestContract.clear.puya.map b/test_cases/structure_methods/out_unoptimized/TestContract.clear.puya.map new file mode 100644 index 0000000000..14b1fb68e5 --- /dev/null +++ b/test_cases/structure_methods/out_unoptimized/TestContract.clear.puya.map @@ -0,0 +1,30 @@ +{ + "version": 3, + "sources": [], + "mappings": ";;;;;;", + "op_pc_offset": 0, + "pc_events": { + "1": { + "subroutine": "algopy.arc4.ARC4Contract.clear_state_program", + "params": {}, + "block": "main", + "stack_in": [], + "op": "b main_block@0" + }, + "4": { + "block": "main_block@0", + "stack_in": [], + "op": "pushint 1", + "defined_out": [ + "1" + ], + "stack_out": [ + "1" + ] + }, + "6": { + "op": "return", + "stack_out": [] + } + } +} \ No newline at end of file diff --git a/test_cases/structure_methods/out_unoptimized/TestContract.clear.stats.txt b/test_cases/structure_methods/out_unoptimized/TestContract.clear.stats.txt new file mode 100644 index 0000000000..e712c0b643 --- /dev/null +++ b/test_cases/structure_methods/out_unoptimized/TestContract.clear.stats.txt @@ -0,0 +1,10 @@ +total_bytes = 7 +total_ops = 3 +constant_bytes = 2 +constant_ops = 1 +control_flow_bytes = 3 +control_flow_ops = 1 +stack_bytes = 0 +stack_ops = 0 +other_bytes = 1 +other_ops = 1 \ No newline at end of file diff --git a/test_cases/structure_methods/out_unoptimized/TestContract.clear.teal b/test_cases/structure_methods/out_unoptimized/TestContract.clear.teal new file mode 100644 index 0000000000..0ac9fb0cee --- /dev/null +++ b/test_cases/structure_methods/out_unoptimized/TestContract.clear.teal @@ -0,0 +1,10 @@ +#pragma version 11 +#pragma typetrack false + +// algopy.arc4.ARC4Contract.clear_state_program() -> uint64: +main: + b main_block@0 + +main_block@0: + pushint 1 + return diff --git a/test_cases/structure_methods/out_unoptimized/TestContract.ir/TestContract.approval.400.destructured.ir b/test_cases/structure_methods/out_unoptimized/TestContract.ir/TestContract.approval.400.destructured.ir new file mode 100644 index 0000000000..10ac526fc5 --- /dev/null +++ b/test_cases/structure_methods/out_unoptimized/TestContract.ir/TestContract.approval.400.destructured.ir @@ -0,0 +1,360 @@ +main algopy.arc4.ARC4Contract.approval_program: + block@0: // L1 + goto block@1 + block@1: // L69 + let tmp%0#1: uint64 = (txn NumAppArgs) + let tmp%1#0: bool = (!= tmp%0#1 0u) + goto tmp%1#0 ? block@2 : block@5 + block@2: // abi_routing_L69 + let tmp%2#0: bytes = (txna ApplicationArgs 0) + switch tmp%2#0 {method "test()void" => block@3, * => block@4} + block@3: // test_route_L70 + let tmp%3#0: uint64 = (txn OnCompletion) + let tmp%4#0: bool = (== tmp%3#0 NoOp) + let tmp%5#0: uint64 = (txn ApplicationID) + let tmp%6#0: bool = (!= tmp%5#0 0u) + let tmp%7#0: bool = (&& tmp%4#0 tmp%6#0) + (assert tmp%7#0) + test_cases.structure_methods.contract.TestContract.test[routing]() + goto block@4 + block@4: // switch_case_next_L69 + goto block@6 + block@5: // __algopy_default_create_L1 + let tmp%8#0: uint64 = (txn OnCompletion) + let tmp%9#0: bool = (== tmp%8#0 NoOp) + let tmp%10#0: uint64 = (txn ApplicationID) + let tmp%11#0: bool = (== tmp%10#0 0u) + let tmp%12#0: bool = (&& tmp%9#0 tmp%11#0) + (assert tmp%12#0) + goto block@8 + block@8: // L1 + goto block@9 + block@9: // after_inlined_test_cases.structure_methods.contract.TestContract.__algopy_default_create_L1 + exit 1u + block@6: // after_if_else_L69 + exit 0u + block@7: // after_inlined_test_cases.structure_methods.contract.TestContract.__puya_arc4_router___L1 + let tmp%0#0: bool = undefined + return tmp%0#0 + +subroutine test_cases.structure_methods.contract.ARC4TestStruct.return_value_times(self: Encoded(uint64), times: uint64) -> : + block@0: // L9 + let aggregate%extract%0#0: bytes = (extract3 self#0 0u 8u) + let tuple_item%0#0: Encoded(uint64) = aggregate%extract%0#0 + let tmp%0#0: uint64 = (btoi tuple_item%0#0) + let tmp%1#0: uint64 = (* tmp%0#0 times#0) + return tmp%1#0 self#0 + +subroutine test_cases.structure_methods.contract.ARC4TestStruct.return1() -> uint64: + block@0: // L12 + return 1u + +subroutine test_cases.structure_methods.contract.TestStruct.return_value_times(self: Encoded(uint64), times: uint64) -> : + block@0: // L20 + let aggregate%extract%0#0: bytes = (extract3 self#0 0u 8u) + let tuple_item%0#0: Encoded(uint64) = aggregate%extract%0#0 + let values%0#0: uint64 = (btoi tuple_item%0#0) + let tmp%0#0: uint64 = (* values%0#0 times#0) + return tmp%0#0 self#0 + +subroutine test_cases.structure_methods.contract.TestStruct.return1() -> uint64: + block@0: // L23 + return 1u + +subroutine test_cases.structure_methods.contract.TestNamedTuple.return_value_times(self.value: uint64, times: uint64) -> uint64: + block@0: // L31 + let tmp%0#0: uint64 = (* self.value#0 times#0) + return tmp%0#0 + +subroutine test_cases.structure_methods.contract.TestNamedTuple.return1() -> uint64: + block@0: // L34 + return 1u + +subroutine test_cases.structure_methods.contract.GroupedMethods.never_inlined_usually_inlined(v: uint64) -> uint64: + block@0: // L40 + let tmp%0#0: uint64 = (+ v#0 1u) + return tmp%0#0 + +subroutine test_cases.structure_methods.contract.GroupedMethods.usually_inlined(v: uint64) -> uint64: + block@0: // L55 + let tmp%0#0: uint64 = (+ v#0 1u) + return tmp%0#0 + +subroutine test_cases.structure_methods.contract.GroupedMethods.not_usually_inlined(v: uint64) -> void: + block@0: // L58 + let aggregate%val_as_bytes%0#0: bytes[8] = (itob v#0) + let aggregate%as_Encoded(uint64)%0#0: Encoded(uint64) = aggregate%val_as_bytes%0#0 + let tmp%0#0: Encoded(uint64) = aggregate%as_Encoded(uint64)%0#0 + let aggregate%head%0#0: bytes = (concat 0x tmp%0#0) + let aggregate%as_Encoded(uint64)%1#0: Encoded(uint64) = aggregate%head%0#0 + let tmp%1#0: Encoded(uint64) = aggregate%as_Encoded(uint64)%1#0 + let event%0#0: bytes = (concat method "ARC4TestStruct(uint64)" tmp%1#0) + (log event%0#0) + let aggregate%val_as_bytes%1#0: bytes[8] = (itob v#0) + let aggregate%as_Encoded(uint64)%2#0: Encoded(uint64) = aggregate%val_as_bytes%1#0 + let tmp%2#0: Encoded(uint64) = aggregate%as_Encoded(uint64)%2#0 + let aggregate%head%1#0: bytes = (concat 0x tmp%2#0) + let aggregate%as_Encoded(uint64)%3#0: Encoded(uint64) = aggregate%head%1#0 + let tmp%3#0: Encoded(uint64) = aggregate%as_Encoded(uint64)%3#0 + let event%1#0: bytes = (concat method "ARC4TestStruct(uint64)" tmp%3#0) + (log event%1#0) + let aggregate%val_as_bytes%2#0: bytes[8] = (itob v#0) + let aggregate%as_Encoded(uint64)%4#0: Encoded(uint64) = aggregate%val_as_bytes%2#0 + let tmp%4#0: Encoded(uint64) = aggregate%as_Encoded(uint64)%4#0 + let aggregate%head%2#0: bytes = (concat 0x tmp%4#0) + let aggregate%as_Encoded(uint64)%5#0: Encoded(uint64) = aggregate%head%2#0 + let tmp%5#0: Encoded(uint64) = aggregate%as_Encoded(uint64)%5#0 + let event%2#0: bytes = (concat method "ARC4TestStruct(uint64)" tmp%5#0) + (log event%2#0) + let aggregate%val_as_bytes%3#0: bytes[8] = (itob v#0) + let aggregate%as_Encoded(uint64)%6#0: Encoded(uint64) = aggregate%val_as_bytes%3#0 + let tmp%6#0: Encoded(uint64) = aggregate%as_Encoded(uint64)%6#0 + let aggregate%head%3#0: bytes = (concat 0x tmp%6#0) + let aggregate%as_Encoded(uint64)%7#0: Encoded(uint64) = aggregate%head%3#0 + let tmp%7#0: Encoded(uint64) = aggregate%as_Encoded(uint64)%7#0 + let event%3#0: bytes = (concat method "ARC4TestStruct(uint64)" tmp%7#0) + (log event%3#0) + let aggregate%val_as_bytes%4#0: bytes[8] = (itob v#0) + let aggregate%as_Encoded(uint64)%8#0: Encoded(uint64) = aggregate%val_as_bytes%4#0 + let tmp%8#0: Encoded(uint64) = aggregate%as_Encoded(uint64)%8#0 + let aggregate%head%4#0: bytes = (concat 0x tmp%8#0) + let aggregate%as_Encoded(uint64)%9#0: Encoded(uint64) = aggregate%head%4#0 + let tmp%9#0: Encoded(uint64) = aggregate%as_Encoded(uint64)%9#0 + let event%4#0: bytes = (concat method "ARC4TestStruct(uint64)" tmp%9#0) + (log event%4#0) + let aggregate%val_as_bytes%5#0: bytes[8] = (itob v#0) + let aggregate%as_Encoded(uint64)%10#0: Encoded(uint64) = aggregate%val_as_bytes%5#0 + let tmp%10#0: Encoded(uint64) = aggregate%as_Encoded(uint64)%10#0 + let aggregate%head%5#0: bytes = (concat 0x tmp%10#0) + let aggregate%as_Encoded(uint64)%11#0: Encoded(uint64) = aggregate%head%5#0 + let tmp%11#0: Encoded(uint64) = aggregate%as_Encoded(uint64)%11#0 + let event%5#0: bytes = (concat method "ARC4TestStruct(uint64)" tmp%11#0) + (log event%5#0) + let aggregate%val_as_bytes%6#0: bytes[8] = (itob v#0) + let aggregate%as_Encoded(uint64)%12#0: Encoded(uint64) = aggregate%val_as_bytes%6#0 + let tmp%12#0: Encoded(uint64) = aggregate%as_Encoded(uint64)%12#0 + let aggregate%head%6#0: bytes = (concat 0x tmp%12#0) + let aggregate%as_Encoded(uint64)%13#0: Encoded(uint64) = aggregate%head%6#0 + let tmp%13#0: Encoded(uint64) = aggregate%as_Encoded(uint64)%13#0 + let event%6#0: bytes = (concat method "ARC4TestStruct(uint64)" tmp%13#0) + (log event%6#0) + let aggregate%val_as_bytes%7#0: bytes[8] = (itob v#0) + let aggregate%as_Encoded(uint64)%14#0: Encoded(uint64) = aggregate%val_as_bytes%7#0 + let tmp%14#0: Encoded(uint64) = aggregate%as_Encoded(uint64)%14#0 + let aggregate%head%7#0: bytes = (concat 0x tmp%14#0) + let aggregate%as_Encoded(uint64)%15#0: Encoded(uint64) = aggregate%head%7#0 + let tmp%15#0: Encoded(uint64) = aggregate%as_Encoded(uint64)%15#0 + let event%7#0: bytes = (concat method "ARC4TestStruct(uint64)" tmp%15#0) + (log event%7#0) + return + +subroutine test_cases.structure_methods.contract.TestContract.test[routing]() -> void: + block@0: // L70 + test_cases.structure_methods.contract.TestContract.test() + exit 1u + +subroutine test_cases.structure_methods.contract.TestContract.test() -> void: + block@0: // L70 + let aggregate%head%0#0: bytes = (concat 0x 0x0000000000000009) + let aggregate%as_Encoded(uint64)%0#0: Encoded(uint64) = aggregate%head%0#0 + let tmp%0#0: bytes = aggregate%as_Encoded(uint64)%0#0 + let (return_value_times%0#0: uint64, return_value_times%1#0: Encoded(uint64)) = test_cases.structure_methods.contract.ARC4TestStruct.return_value_times(tmp%0#0, 2u) + let tmp%1#0: bool = (== 18u return_value_times%0#0) + (assert tmp%1#0) + let aggregate%val_as_bytes%0#0: bytes[8] = (itob 9u) + let aggregate%as_Encoded(uint64)%1#0: Encoded(uint64) = aggregate%val_as_bytes%0#0 + let aggregate%head%1#0: bytes = (concat 0x aggregate%as_Encoded(uint64)%1#0) + let aggregate%as_Encoded(uint64)%2#0: Encoded(uint64) = aggregate%head%1#0 + let tmp%2#0: bytes = aggregate%as_Encoded(uint64)%2#0 + let (return_value_times%2#0: uint64, return_value_times%3#0: Encoded(uint64)) = test_cases.structure_methods.contract.TestStruct.return_value_times(tmp%2#0, 2u) + let tmp%3#0: bool = (== 18u return_value_times%2#0) + (assert tmp%3#0) + let tmp%4#0: uint64 = test_cases.structure_methods.contract.TestNamedTuple.return_value_times(9u, 2u) + let tmp%5#0: bool = (== 18u tmp%4#0) + (assert tmp%5#0) + let aggregate%head%2#0: bytes = (concat 0x 0x0000000000000009) + let aggregate%as_Encoded(uint64)%3#0: Encoded(uint64) = aggregate%head%2#0 + let tmp%6#0: bytes = aggregate%as_Encoded(uint64)%3#0 + let (return_value_times%4#0: uint64, return_value_times%5#0: Encoded(uint64)) = test_cases.structure_methods.contract.ARC4TestStruct.return_value_times(tmp%6#0, 2u) + let tmp%7#0: bool = (== 18u return_value_times%4#0) + (assert tmp%7#0) + let aggregate%val_as_bytes%1#0: bytes[8] = (itob 9u) + let aggregate%as_Encoded(uint64)%4#0: Encoded(uint64) = aggregate%val_as_bytes%1#0 + let aggregate%head%3#0: bytes = (concat 0x aggregate%as_Encoded(uint64)%4#0) + let aggregate%as_Encoded(uint64)%5#0: Encoded(uint64) = aggregate%head%3#0 + let tmp%8#0: bytes = aggregate%as_Encoded(uint64)%5#0 + let (return_value_times%6#0: uint64, return_value_times%7#0: Encoded(uint64)) = test_cases.structure_methods.contract.TestStruct.return_value_times(tmp%8#0, 2u) + let tmp%9#0: bool = (== 18u return_value_times%6#0) + (assert tmp%9#0) + let tmp%10#0: uint64 = test_cases.structure_methods.contract.TestNamedTuple.return_value_times(9u, 2u) + let tmp%11#0: bool = (== 18u tmp%10#0) + (assert tmp%11#0) + let tmp%12#0: uint64 = test_cases.structure_methods.contract.ARC4TestStruct.return1() + let tmp%13#0: bool = (== 1u tmp%12#0) + (assert tmp%13#0) + let tmp%14#0: uint64 = test_cases.structure_methods.contract.TestStruct.return1() + let tmp%15#0: bool = (== 1u tmp%14#0) + (assert tmp%15#0) + let tmp%16#0: uint64 = test_cases.structure_methods.contract.TestNamedTuple.return1() + let tmp%17#0: bool = (== 1u tmp%16#0) + (assert tmp%17#0) + let tmp%18#0: uint64 = test_cases.structure_methods.contract.ARC4TestStruct.return1() + let tmp%19#0: bool = (== 1u tmp%18#0) + (assert tmp%19#0) + let tmp%20#0: uint64 = test_cases.structure_methods.contract.TestStruct.return1() + let tmp%21#0: bool = (== 1u tmp%20#0) + (assert tmp%21#0) + let tmp%22#0: uint64 = test_cases.structure_methods.contract.TestNamedTuple.return1() + let tmp%23#0: bool = (== 1u tmp%22#0) + (assert tmp%23#0) + let tmp%24#0: uint64 = test_cases.structure_methods.contract.GroupedMethods.never_inlined_usually_inlined(2u) + let tmp%25#0: bool = (== 3u tmp%24#0) + (assert tmp%25#0) + let tmp%26#0: uint64 = test_cases.structure_methods.contract.GroupedMethods.never_inlined_usually_inlined(2u) + let tmp%27#0: bool = (== 3u tmp%26#0) + (assert tmp%27#0) + let tmp%28#0: uint64 = test_cases.structure_methods.contract.GroupedMethods.usually_inlined(2u) + let tmp%29#0: bool = (== 3u tmp%28#0) + (assert tmp%29#0) + let tmp%30#0: uint64 = test_cases.structure_methods.contract.GroupedMethods.usually_inlined(2u) + let tmp%31#0: bool = (== 3u tmp%30#0) + (assert tmp%31#0) + goto block@1 + block@1: // L44 + let aggregate%val_as_bytes%2#0: bytes[8] = (itob 2u) + let aggregate%as_Encoded(uint64)%6#0: Encoded(uint64) = aggregate%val_as_bytes%2#0 + let tmp%0#0: bytes = aggregate%as_Encoded(uint64)%6#0 + let aggregate%head%4#0: bytes = (concat 0x tmp%0#0) + let aggregate%as_Encoded(uint64)%7#0: Encoded(uint64) = aggregate%head%4#0 + let tmp%1#1: Encoded(uint64) = aggregate%as_Encoded(uint64)%7#0 + let event%0#0: bytes = (concat method "ARC4TestStruct(uint64)" tmp%1#1) + (log event%0#0) + let aggregate%val_as_bytes%3#0: bytes[8] = (itob 2u) + let aggregate%as_Encoded(uint64)%8#0: Encoded(uint64) = aggregate%val_as_bytes%3#0 + let tmp%2#0: bytes = aggregate%as_Encoded(uint64)%8#0 + let aggregate%head%5#0: bytes = (concat 0x tmp%2#0) + let aggregate%as_Encoded(uint64)%9#0: Encoded(uint64) = aggregate%head%5#0 + let tmp%3#1: Encoded(uint64) = aggregate%as_Encoded(uint64)%9#0 + let event%1#0: bytes = (concat method "ARC4TestStruct(uint64)" tmp%3#1) + (log event%1#0) + let aggregate%val_as_bytes%4#0: bytes[8] = (itob 2u) + let aggregate%as_Encoded(uint64)%10#0: Encoded(uint64) = aggregate%val_as_bytes%4#0 + let tmp%4#1: Encoded(uint64) = aggregate%as_Encoded(uint64)%10#0 + let aggregate%head%6#0: bytes = (concat 0x tmp%4#1) + let aggregate%as_Encoded(uint64)%11#0: Encoded(uint64) = aggregate%head%6#0 + let tmp%5#1: Encoded(uint64) = aggregate%as_Encoded(uint64)%11#0 + let event%2#0: bytes = (concat method "ARC4TestStruct(uint64)" tmp%5#1) + (log event%2#0) + let aggregate%val_as_bytes%5#0: bytes[8] = (itob 2u) + let aggregate%as_Encoded(uint64)%12#0: Encoded(uint64) = aggregate%val_as_bytes%5#0 + let tmp%6#0: bytes = aggregate%as_Encoded(uint64)%12#0 + let aggregate%head%7#0: bytes = (concat 0x tmp%6#0) + let aggregate%as_Encoded(uint64)%13#0: Encoded(uint64) = aggregate%head%7#0 + let tmp%7#1: Encoded(uint64) = aggregate%as_Encoded(uint64)%13#0 + let event%3#0: bytes = (concat method "ARC4TestStruct(uint64)" tmp%7#1) + (log event%3#0) + let aggregate%val_as_bytes%6#0: bytes[8] = (itob 2u) + let aggregate%as_Encoded(uint64)%14#0: Encoded(uint64) = aggregate%val_as_bytes%6#0 + let tmp%8#0: bytes = aggregate%as_Encoded(uint64)%14#0 + let aggregate%head%8#0: bytes = (concat 0x tmp%8#0) + let aggregate%as_Encoded(uint64)%15#0: Encoded(uint64) = aggregate%head%8#0 + let tmp%9#1: Encoded(uint64) = aggregate%as_Encoded(uint64)%15#0 + let event%4#0: bytes = (concat method "ARC4TestStruct(uint64)" tmp%9#1) + (log event%4#0) + let aggregate%val_as_bytes%7#0: bytes[8] = (itob 2u) + let aggregate%as_Encoded(uint64)%16#0: Encoded(uint64) = aggregate%val_as_bytes%7#0 + let tmp%10#1: Encoded(uint64) = aggregate%as_Encoded(uint64)%16#0 + let aggregate%head%9#0: bytes = (concat 0x tmp%10#1) + let aggregate%as_Encoded(uint64)%17#0: Encoded(uint64) = aggregate%head%9#0 + let tmp%11#1: Encoded(uint64) = aggregate%as_Encoded(uint64)%17#0 + let event%5#0: bytes = (concat method "ARC4TestStruct(uint64)" tmp%11#1) + (log event%5#0) + let aggregate%val_as_bytes%8#0: bytes[8] = (itob 2u) + let aggregate%as_Encoded(uint64)%18#0: Encoded(uint64) = aggregate%val_as_bytes%8#0 + let tmp%12#1: Encoded(uint64) = aggregate%as_Encoded(uint64)%18#0 + let aggregate%head%10#0: bytes = (concat 0x tmp%12#1) + let aggregate%as_Encoded(uint64)%19#0: Encoded(uint64) = aggregate%head%10#0 + let tmp%13#1: Encoded(uint64) = aggregate%as_Encoded(uint64)%19#0 + let event%6#0: bytes = (concat method "ARC4TestStruct(uint64)" tmp%13#1) + (log event%6#0) + let aggregate%val_as_bytes%9#0: bytes[8] = (itob 2u) + let aggregate%as_Encoded(uint64)%20#0: Encoded(uint64) = aggregate%val_as_bytes%9#0 + let tmp%14#1: Encoded(uint64) = aggregate%as_Encoded(uint64)%20#0 + let aggregate%head%11#0: bytes = (concat 0x tmp%14#1) + let aggregate%as_Encoded(uint64)%21#0: Encoded(uint64) = aggregate%head%11#0 + let tmp%15#1: Encoded(uint64) = aggregate%as_Encoded(uint64)%21#0 + let event%7#0: bytes = (concat method "ARC4TestStruct(uint64)" tmp%15#1) + (log event%7#0) + goto block@2 + block@2: // after_inlined_test_cases.structure_methods.contract.GroupedMethods.always_inlined_not_usually_inlined_L70 + goto block@3 + block@3: // L44 + let aggregate%val_as_bytes%10#0: bytes[8] = (itob 2u) + let aggregate%as_Encoded(uint64)%22#0: Encoded(uint64) = aggregate%val_as_bytes%10#0 + let tmp%0#0: bytes = aggregate%as_Encoded(uint64)%22#0 + let aggregate%head%12#0: bytes = (concat 0x tmp%0#0) + let aggregate%as_Encoded(uint64)%23#0: Encoded(uint64) = aggregate%head%12#0 + let tmp%1#1: Encoded(uint64) = aggregate%as_Encoded(uint64)%23#0 + let event%0#0: bytes = (concat method "ARC4TestStruct(uint64)" tmp%1#1) + (log event%0#0) + let aggregate%val_as_bytes%11#0: bytes[8] = (itob 2u) + let aggregate%as_Encoded(uint64)%24#0: Encoded(uint64) = aggregate%val_as_bytes%11#0 + let tmp%2#0: bytes = aggregate%as_Encoded(uint64)%24#0 + let aggregate%head%13#0: bytes = (concat 0x tmp%2#0) + let aggregate%as_Encoded(uint64)%25#0: Encoded(uint64) = aggregate%head%13#0 + let tmp%3#1: Encoded(uint64) = aggregate%as_Encoded(uint64)%25#0 + let event%1#0: bytes = (concat method "ARC4TestStruct(uint64)" tmp%3#1) + (log event%1#0) + let aggregate%val_as_bytes%12#0: bytes[8] = (itob 2u) + let aggregate%as_Encoded(uint64)%26#0: Encoded(uint64) = aggregate%val_as_bytes%12#0 + let tmp%4#1: Encoded(uint64) = aggregate%as_Encoded(uint64)%26#0 + let aggregate%head%14#0: bytes = (concat 0x tmp%4#1) + let aggregate%as_Encoded(uint64)%27#0: Encoded(uint64) = aggregate%head%14#0 + let tmp%5#1: Encoded(uint64) = aggregate%as_Encoded(uint64)%27#0 + let event%2#0: bytes = (concat method "ARC4TestStruct(uint64)" tmp%5#1) + (log event%2#0) + let aggregate%val_as_bytes%13#0: bytes[8] = (itob 2u) + let aggregate%as_Encoded(uint64)%28#0: Encoded(uint64) = aggregate%val_as_bytes%13#0 + let tmp%6#0: bytes = aggregate%as_Encoded(uint64)%28#0 + let aggregate%head%15#0: bytes = (concat 0x tmp%6#0) + let aggregate%as_Encoded(uint64)%29#0: Encoded(uint64) = aggregate%head%15#0 + let tmp%7#1: Encoded(uint64) = aggregate%as_Encoded(uint64)%29#0 + let event%3#0: bytes = (concat method "ARC4TestStruct(uint64)" tmp%7#1) + (log event%3#0) + let aggregate%val_as_bytes%14#0: bytes[8] = (itob 2u) + let aggregate%as_Encoded(uint64)%30#0: Encoded(uint64) = aggregate%val_as_bytes%14#0 + let tmp%8#0: bytes = aggregate%as_Encoded(uint64)%30#0 + let aggregate%head%16#0: bytes = (concat 0x tmp%8#0) + let aggregate%as_Encoded(uint64)%31#0: Encoded(uint64) = aggregate%head%16#0 + let tmp%9#1: Encoded(uint64) = aggregate%as_Encoded(uint64)%31#0 + let event%4#0: bytes = (concat method "ARC4TestStruct(uint64)" tmp%9#1) + (log event%4#0) + let aggregate%val_as_bytes%15#0: bytes[8] = (itob 2u) + let aggregate%as_Encoded(uint64)%32#0: Encoded(uint64) = aggregate%val_as_bytes%15#0 + let tmp%10#1: Encoded(uint64) = aggregate%as_Encoded(uint64)%32#0 + let aggregate%head%17#0: bytes = (concat 0x tmp%10#1) + let aggregate%as_Encoded(uint64)%33#0: Encoded(uint64) = aggregate%head%17#0 + let tmp%11#1: Encoded(uint64) = aggregate%as_Encoded(uint64)%33#0 + let event%5#0: bytes = (concat method "ARC4TestStruct(uint64)" tmp%11#1) + (log event%5#0) + let aggregate%val_as_bytes%16#0: bytes[8] = (itob 2u) + let aggregate%as_Encoded(uint64)%34#0: Encoded(uint64) = aggregate%val_as_bytes%16#0 + let tmp%12#1: Encoded(uint64) = aggregate%as_Encoded(uint64)%34#0 + let aggregate%head%18#0: bytes = (concat 0x tmp%12#1) + let aggregate%as_Encoded(uint64)%35#0: Encoded(uint64) = aggregate%head%18#0 + let tmp%13#1: Encoded(uint64) = aggregate%as_Encoded(uint64)%35#0 + let event%6#0: bytes = (concat method "ARC4TestStruct(uint64)" tmp%13#1) + (log event%6#0) + let aggregate%val_as_bytes%17#0: bytes[8] = (itob 2u) + let aggregate%as_Encoded(uint64)%36#0: Encoded(uint64) = aggregate%val_as_bytes%17#0 + let tmp%14#1: Encoded(uint64) = aggregate%as_Encoded(uint64)%36#0 + let aggregate%head%19#0: bytes = (concat 0x tmp%14#1) + let aggregate%as_Encoded(uint64)%37#0: Encoded(uint64) = aggregate%head%19#0 + let tmp%15#1: Encoded(uint64) = aggregate%as_Encoded(uint64)%37#0 + let event%7#0: bytes = (concat method "ARC4TestStruct(uint64)" tmp%15#1) + (log event%7#0) + goto block@4 + block@4: // after_inlined_test_cases.structure_methods.contract.GroupedMethods.always_inlined_not_usually_inlined_L70 + test_cases.structure_methods.contract.GroupedMethods.not_usually_inlined(2u) + test_cases.structure_methods.contract.GroupedMethods.not_usually_inlined(2u) + return \ No newline at end of file diff --git a/test_cases/structure_methods/out_unoptimized/TestContract.ir/TestContract.clear.400.destructured.ir b/test_cases/structure_methods/out_unoptimized/TestContract.ir/TestContract.clear.400.destructured.ir new file mode 100644 index 0000000000..b19ab730e7 --- /dev/null +++ b/test_cases/structure_methods/out_unoptimized/TestContract.ir/TestContract.clear.400.destructured.ir @@ -0,0 +1,3 @@ +main algopy.arc4.ARC4Contract.clear_state_program: + block@0: // L1 + return 1u \ No newline at end of file diff --git a/test_cases/structure_methods/puya.log b/test_cases/structure_methods/puya.log new file mode 100644 index 0000000000..f82bdd18d1 --- /dev/null +++ b/test_cases/structure_methods/puya.log @@ -0,0 +1,2380 @@ +debug: PuyaPyOptions(output_teal=True, output_source_map=True, output_arc32=False, output_arc56=True, output_ssa_ir=True, output_optimization_ir=True, output_destructured_ir=True, output_memory_ir=True, output_bytecode=True, output_teal_intermediates=False, output_op_statistics=True, debug_level=1, optimization_level=1, target_avm_version=11, cli_template_definitions={}, template_vars_prefix='TMPL_', locals_coalescing_strategy=, optimizations_override=immutabledict({}), expand_all_bytes=False, validate_abi_args=True, validate_abi_return=True, paths=['structure_methods'], resource_encoding='value', output_awst=True, output_awst_json=False, output_source_annotations_json=False, output_client=True, log_level=) +info: writing structure_methods/out/module.awst +debug: Building IR for function _puya_lib.util.ensure_budget +debug: Sealing block@0 +debug: Terminated block@0 +debug: Looking for 'required_budget_with_buffer' in an unsealed block creating an incomplete Phi: block@1 +debug: Created Phi assignment: let required_budget_with_buffer#1: uint64 = undefined while trying to resolve 'required_budget_with_buffer' in block@1 +debug: Terminated block@1 +debug: Sealing block@2 +debug: Looking for 'fee_source' in an unsealed block creating an incomplete Phi: block@1 +debug: Created Phi assignment: let fee_source#1: uint64 = undefined while trying to resolve 'fee_source' in block@1 +debug: Terminated block@2 +debug: Terminated block@3 +debug: Terminated block@4 +debug: Sealing block@5 +debug: Terminated block@5 +debug: Sealing block@1 +debug: Added required_budget_with_buffer#0 to Phi node: let required_budget_with_buffer#1: uint64 = φ(required_budget_with_buffer#0 <- block@0) in block@0 +debug: Created Phi assignment: let required_budget_with_buffer#2: uint64 = undefined while trying to resolve 'required_budget_with_buffer' in block@5 +debug: Added required_budget_with_buffer#1 to Phi node: let required_budget_with_buffer#2: uint64 = φ(required_budget_with_buffer#1 <- block@2) in block@2 +debug: Looking for 'required_budget_with_buffer' in an unsealed block creating an incomplete Phi: block@3 +debug: Created Phi assignment: let required_budget_with_buffer#3: uint64 = undefined while trying to resolve 'required_budget_with_buffer' in block@3 +debug: Added required_budget_with_buffer#3 to Phi node: let required_budget_with_buffer#2: uint64 = φ(required_budget_with_buffer#1 <- block@2, required_budget_with_buffer#3 <- block@3) in block@3 +debug: Looking for 'required_budget_with_buffer' in an unsealed block creating an incomplete Phi: block@4 +debug: Created Phi assignment: let required_budget_with_buffer#4: uint64 = undefined while trying to resolve 'required_budget_with_buffer' in block@4 +debug: Added required_budget_with_buffer#4 to Phi node: let required_budget_with_buffer#2: uint64 = φ(required_budget_with_buffer#1 <- block@2, required_budget_with_buffer#3 <- block@3, required_budget_with_buffer#4 <- block@4) in block@4 +debug: Added required_budget_with_buffer#2 to Phi node: let required_budget_with_buffer#1: uint64 = φ(required_budget_with_buffer#0 <- block@0, required_budget_with_buffer#2 <- block@5) in block@5 +debug: Added fee_source#0 to Phi node: let fee_source#1: uint64 = φ(fee_source#0 <- block@0) in block@0 +debug: Created Phi assignment: let fee_source#2: uint64 = undefined while trying to resolve 'fee_source' in block@5 +debug: Added fee_source#1 to Phi node: let fee_source#2: uint64 = φ(fee_source#1 <- block@2) in block@2 +debug: Looking for 'fee_source' in an unsealed block creating an incomplete Phi: block@3 +debug: Created Phi assignment: let fee_source#3: uint64 = undefined while trying to resolve 'fee_source' in block@3 +debug: Added fee_source#3 to Phi node: let fee_source#2: uint64 = φ(fee_source#1 <- block@2, fee_source#3 <- block@3) in block@3 +debug: Looking for 'fee_source' in an unsealed block creating an incomplete Phi: block@4 +debug: Created Phi assignment: let fee_source#4: uint64 = undefined while trying to resolve 'fee_source' in block@4 +debug: Added fee_source#4 to Phi node: let fee_source#2: uint64 = φ(fee_source#1 <- block@2, fee_source#3 <- block@3, fee_source#4 <- block@4) in block@4 +debug: Added fee_source#2 to Phi node: let fee_source#1: uint64 = φ(fee_source#0 <- block@0, fee_source#2 <- block@5) in block@5 +debug: Sealing block@6 +debug: Terminated block@6 +debug: Sealing block@3 +debug: Added required_budget_with_buffer#1 to Phi node: let required_budget_with_buffer#3: uint64 = φ(required_budget_with_buffer#1 <- block@2) in block@2 +debug: Replacing trivial Phi node: let required_budget_with_buffer#3: uint64 = φ(required_budget_with_buffer#1 <- block@2) (required_budget_with_buffer#3) with required_budget_with_buffer#1 +debug: Deleting Phi assignment: let required_budget_with_buffer#3: uint64 = φ(required_budget_with_buffer#1 <- block@2) +debug: Replaced trivial Phi node: let required_budget_with_buffer#3: uint64 = φ(required_budget_with_buffer#1 <- block@2) (required_budget_with_buffer#3) with required_budget_with_buffer#1 in current definition for 1 blocks +debug: Added fee_source#1 to Phi node: let fee_source#3: uint64 = φ(fee_source#1 <- block@2) in block@2 +debug: Replacing trivial Phi node: let fee_source#3: uint64 = φ(fee_source#1 <- block@2) (fee_source#3) with fee_source#1 +debug: Deleting Phi assignment: let fee_source#3: uint64 = φ(fee_source#1 <- block@2) +debug: Replaced trivial Phi node: let fee_source#3: uint64 = φ(fee_source#1 <- block@2) (fee_source#3) with fee_source#1 in current definition for 1 blocks +debug: Sealing block@4 +debug: Added required_budget_with_buffer#1 to Phi node: let required_budget_with_buffer#4: uint64 = φ(required_budget_with_buffer#1 <- block@2) in block@2 +debug: Replacing trivial Phi node: let required_budget_with_buffer#4: uint64 = φ(required_budget_with_buffer#1 <- block@2) (required_budget_with_buffer#4) with required_budget_with_buffer#1 +debug: Deleting Phi assignment: let required_budget_with_buffer#4: uint64 = φ(required_budget_with_buffer#1 <- block@2) +debug: Replacing trivial Phi node: let required_budget_with_buffer#2: uint64 = φ(required_budget_with_buffer#1 <- block@2, required_budget_with_buffer#1 <- block@3, required_budget_with_buffer#1 <- block@4) (required_budget_with_buffer#2) with required_budget_with_buffer#1 +debug: Deleting Phi assignment: let required_budget_with_buffer#2: uint64 = φ(required_budget_with_buffer#1 <- block@2, required_budget_with_buffer#1 <- block@3, required_budget_with_buffer#1 <- block@4) +debug: Replacing trivial Phi node: let required_budget_with_buffer#1: uint64 = φ(required_budget_with_buffer#0 <- block@0, required_budget_with_buffer#1 <- block@5) (required_budget_with_buffer#1) with required_budget_with_buffer#0 +debug: Deleting Phi assignment: let required_budget_with_buffer#1: uint64 = φ(required_budget_with_buffer#0 <- block@0, required_budget_with_buffer#1 <- block@5) +debug: Replaced trivial Phi node: let required_budget_with_buffer#4: uint64 = φ(required_budget_with_buffer#1 <- block@2) (required_budget_with_buffer#4) with required_budget_with_buffer#1 in current definition for 1 blocks +debug: Replaced trivial Phi node: let required_budget_with_buffer#2: uint64 = φ(required_budget_with_buffer#1 <- block@2, required_budget_with_buffer#1 <- block@3, required_budget_with_buffer#1 <- block@4) (required_budget_with_buffer#2) with required_budget_with_buffer#1 in current definition for 1 blocks +debug: Replaced trivial Phi node: let required_budget_with_buffer#1: uint64 = φ(required_budget_with_buffer#0 <- block@0, required_budget_with_buffer#1 <- block@5) (required_budget_with_buffer#1) with required_budget_with_buffer#0 in current definition for 5 blocks +debug: Added fee_source#1 to Phi node: let fee_source#4: uint64 = φ(fee_source#1 <- block@2) in block@2 +debug: Replacing trivial Phi node: let fee_source#4: uint64 = φ(fee_source#1 <- block@2) (fee_source#4) with fee_source#1 +debug: Deleting Phi assignment: let fee_source#4: uint64 = φ(fee_source#1 <- block@2) +debug: Replacing trivial Phi node: let fee_source#2: uint64 = φ(fee_source#1 <- block@2, fee_source#1 <- block@3, fee_source#1 <- block@4) (fee_source#2) with fee_source#1 +debug: Deleting Phi assignment: let fee_source#2: uint64 = φ(fee_source#1 <- block@2, fee_source#1 <- block@3, fee_source#1 <- block@4) +debug: Replacing trivial Phi node: let fee_source#1: uint64 = φ(fee_source#0 <- block@0, fee_source#1 <- block@5) (fee_source#1) with fee_source#0 +debug: Deleting Phi assignment: let fee_source#1: uint64 = φ(fee_source#0 <- block@0, fee_source#1 <- block@5) +debug: Replaced trivial Phi node: let fee_source#4: uint64 = φ(fee_source#1 <- block@2) (fee_source#4) with fee_source#1 in current definition for 1 blocks +debug: Replaced trivial Phi node: let fee_source#2: uint64 = φ(fee_source#1 <- block@2, fee_source#1 <- block@3, fee_source#1 <- block@4) (fee_source#2) with fee_source#1 in current definition for 1 blocks +debug: Replaced trivial Phi node: let fee_source#1: uint64 = φ(fee_source#0 <- block@0, fee_source#1 <- block@5) (fee_source#1) with fee_source#0 in current definition for 5 blocks +debug: Building IR for function _puya_lib.bytes_.is_substring +debug: Sealing block@0 +debug: Terminated block@0 +debug: Looking for 'start' in an unsealed block creating an incomplete Phi: block@1 +debug: Created Phi assignment: let start#1: uint64 = undefined while trying to resolve 'start' in block@1 +debug: Looking for 'item' in an unsealed block creating an incomplete Phi: block@1 +debug: Created Phi assignment: let item#1: bytes = undefined while trying to resolve 'item' in block@1 +debug: Looking for 'sequence' in an unsealed block creating an incomplete Phi: block@1 +debug: Created Phi assignment: let sequence#1: bytes = undefined while trying to resolve 'sequence' in block@1 +debug: Terminated block@1 +debug: Sealing block@2 +debug: Terminated block@2 +debug: Sealing block@3 +debug: Terminated block@3 +debug: Sealing block@4 +debug: Terminated block@4 +debug: Sealing block@1 +debug: Added start#0 to Phi node: let start#1: uint64 = φ(start#0 <- block@0) in block@0 +debug: Added start#2 to Phi node: let start#1: uint64 = φ(start#0 <- block@0, start#2 <- block@4) in block@4 +debug: Added item#0 to Phi node: let item#1: bytes = φ(item#0 <- block@0) in block@0 +debug: Added item#1 to Phi node: let item#1: bytes = φ(item#0 <- block@0, item#1 <- block@4) in block@4 +debug: Replacing trivial Phi node: let item#1: bytes = φ(item#0 <- block@0, item#1 <- block@4) (item#1) with item#0 +debug: Deleting Phi assignment: let item#1: bytes = φ(item#0 <- block@0, item#1 <- block@4) +debug: Replaced trivial Phi node: let item#1: bytes = φ(item#0 <- block@0, item#1 <- block@4) (item#1) with item#0 in current definition for 3 blocks +debug: Added sequence#0 to Phi node: let sequence#1: bytes = φ(sequence#0 <- block@0) in block@0 +debug: Added sequence#1 to Phi node: let sequence#1: bytes = φ(sequence#0 <- block@0, sequence#1 <- block@4) in block@4 +debug: Replacing trivial Phi node: let sequence#1: bytes = φ(sequence#0 <- block@0, sequence#1 <- block@4) (sequence#1) with sequence#0 +debug: Deleting Phi assignment: let sequence#1: bytes = φ(sequence#0 <- block@0, sequence#1 <- block@4) +debug: Replaced trivial Phi node: let sequence#1: bytes = φ(sequence#0 <- block@0, sequence#1 <- block@4) (sequence#1) with sequence#0 in current definition for 3 blocks +debug: Sealing block@5 +debug: Terminated block@5 +debug: Building IR for function _puya_lib.arc4.dynamic_array_pop_bit +debug: Sealing block@0 +debug: Terminated block@0 +debug: Building IR for function _puya_lib.arc4.dynamic_array_pop_fixed_size +debug: Sealing block@0 +debug: Terminated block@0 +debug: Building IR for function _puya_lib.arc4.dynamic_array_pop_byte_length_head +debug: Sealing block@0 +debug: Terminated block@0 +debug: Building IR for function _puya_lib.arc4.dynamic_array_pop_dynamic_element +debug: Sealing block@0 +debug: Terminated block@0 +debug: Looking for 'value_internal%0' in an unsealed block creating an incomplete Phi: block@1 +debug: Created Phi assignment: let value_internal%0#1: uint64 = undefined while trying to resolve 'value_internal%0' in block@1 +debug: Terminated block@1 +debug: Sealing block@2 +debug: Looking for 'head_and_tail' in an unsealed block creating an incomplete Phi: block@1 +debug: Created Phi assignment: let head_and_tail#1: bytes = undefined while trying to resolve 'head_and_tail' in block@1 +debug: Looking for 'new_head' in an unsealed block creating an incomplete Phi: block@1 +debug: Created Phi assignment: let new_head#1: bytes = undefined while trying to resolve 'new_head' in block@1 +debug: Terminated block@2 +debug: Sealing block@3 +debug: Terminated block@3 +debug: Sealing block@1 +debug: Added value_internal%0#0 to Phi node: let value_internal%0#1: uint64 = φ(value_internal%0#0 <- block@0) in block@0 +debug: Added value_internal%0#2 to Phi node: let value_internal%0#1: uint64 = φ(value_internal%0#0 <- block@0, value_internal%0#2 <- block@3) in block@3 +debug: Added head_and_tail#0 to Phi node: let head_and_tail#1: bytes = φ(head_and_tail#0 <- block@0) in block@0 +debug: Added head_and_tail#1 to Phi node: let head_and_tail#1: bytes = φ(head_and_tail#0 <- block@0, head_and_tail#1 <- block@3) in block@3 +debug: Replacing trivial Phi node: let head_and_tail#1: bytes = φ(head_and_tail#0 <- block@0, head_and_tail#1 <- block@3) (head_and_tail#1) with head_and_tail#0 +debug: Deleting Phi assignment: let head_and_tail#1: bytes = φ(head_and_tail#0 <- block@0, head_and_tail#1 <- block@3) +debug: Replaced trivial Phi node: let head_and_tail#1: bytes = φ(head_and_tail#0 <- block@0, head_and_tail#1 <- block@3) (head_and_tail#1) with head_and_tail#0 in current definition for 3 blocks +debug: Added new_head#0 to Phi node: let new_head#1: bytes = φ(new_head#0 <- block@0) in block@0 +debug: Added new_head#2 to Phi node: let new_head#1: bytes = φ(new_head#0 <- block@0, new_head#2 <- block@3) in block@3 +debug: Sealing block@4 +debug: Created Phi assignment: let length_minus_1#1: uint64 = undefined while trying to resolve 'length_minus_1' in block@1 +debug: Added length_minus_1#0 to Phi node: let length_minus_1#1: uint64 = φ(length_minus_1#0 <- block@0) in block@0 +debug: Added length_minus_1#1 to Phi node: let length_minus_1#1: uint64 = φ(length_minus_1#0 <- block@0, length_minus_1#1 <- block@3) in block@3 +debug: Replacing trivial Phi node: let length_minus_1#1: uint64 = φ(length_minus_1#0 <- block@0, length_minus_1#1 <- block@3) (length_minus_1#1) with length_minus_1#0 +debug: Deleting Phi assignment: let length_minus_1#1: uint64 = φ(length_minus_1#0 <- block@0, length_minus_1#1 <- block@3) +debug: Replaced trivial Phi node: let length_minus_1#1: uint64 = φ(length_minus_1#0 <- block@0, length_minus_1#1 <- block@3) (length_minus_1#1) with length_minus_1#0 in current definition for 3 blocks +debug: Created Phi assignment: let popped_header_offset#1: uint64 = undefined while trying to resolve 'popped_header_offset' in block@1 +debug: Added popped_header_offset#0 to Phi node: let popped_header_offset#1: uint64 = φ(popped_header_offset#0 <- block@0) in block@0 +debug: Added popped_header_offset#1 to Phi node: let popped_header_offset#1: uint64 = φ(popped_header_offset#0 <- block@0, popped_header_offset#1 <- block@3) in block@3 +debug: Replacing trivial Phi node: let popped_header_offset#1: uint64 = φ(popped_header_offset#0 <- block@0, popped_header_offset#1 <- block@3) (popped_header_offset#1) with popped_header_offset#0 +debug: Deleting Phi assignment: let popped_header_offset#1: uint64 = φ(popped_header_offset#0 <- block@0, popped_header_offset#1 <- block@3) +debug: Replaced trivial Phi node: let popped_header_offset#1: uint64 = φ(popped_header_offset#0 <- block@0, popped_header_offset#1 <- block@3) (popped_header_offset#1) with popped_header_offset#0 in current definition for 3 blocks +debug: Created Phi assignment: let popped_offset#1: uint64 = undefined while trying to resolve 'popped_offset' in block@1 +debug: Added popped_offset#0 to Phi node: let popped_offset#1: uint64 = φ(popped_offset#0 <- block@0) in block@0 +debug: Added popped_offset#1 to Phi node: let popped_offset#1: uint64 = φ(popped_offset#0 <- block@0, popped_offset#1 <- block@3) in block@3 +debug: Replacing trivial Phi node: let popped_offset#1: uint64 = φ(popped_offset#0 <- block@0, popped_offset#1 <- block@3) (popped_offset#1) with popped_offset#0 +debug: Deleting Phi assignment: let popped_offset#1: uint64 = φ(popped_offset#0 <- block@0, popped_offset#1 <- block@3) +debug: Replaced trivial Phi node: let popped_offset#1: uint64 = φ(popped_offset#0 <- block@0, popped_offset#1 <- block@3) (popped_offset#1) with popped_offset#0 in current definition for 3 blocks +debug: Created Phi assignment: let popped#1: bytes = undefined while trying to resolve 'popped' in block@1 +debug: Added popped#0 to Phi node: let popped#1: bytes = φ(popped#0 <- block@0) in block@0 +debug: Added popped#1 to Phi node: let popped#1: bytes = φ(popped#0 <- block@0, popped#1 <- block@3) in block@3 +debug: Replacing trivial Phi node: let popped#1: bytes = φ(popped#0 <- block@0, popped#1 <- block@3) (popped#1) with popped#0 +debug: Deleting Phi assignment: let popped#1: bytes = φ(popped#0 <- block@0, popped#1 <- block@3) +debug: Replaced trivial Phi node: let popped#1: bytes = φ(popped#0 <- block@0, popped#1 <- block@3) (popped#1) with popped#0 in current definition for 3 blocks +debug: Terminated block@4 +debug: Building IR for function _puya_lib.arc4.dynamic_array_concat_bits +debug: Sealing block@0 +debug: Terminated block@0 +debug: Sealing block@1 +debug: Terminated block@1 +debug: Sealing block@2 +debug: Created Phi assignment: let array_length#1: uint64 = undefined while trying to resolve 'array_length' in block@2 +debug: Added array_length#0 to Phi node: let array_length#1: uint64 = φ(array_length#0 <- block@0) in block@0 +debug: Added array_length#0 to Phi node: let array_length#1: uint64 = φ(array_length#0 <- block@0, array_length#0 <- block@1) in block@1 +debug: Replacing trivial Phi node: let array_length#1: uint64 = φ(array_length#0 <- block@0, array_length#0 <- block@1) (array_length#1) with array_length#0 +debug: Deleting Phi assignment: let array_length#1: uint64 = φ(array_length#0 <- block@0, array_length#0 <- block@1) +debug: Replaced trivial Phi node: let array_length#1: uint64 = φ(array_length#0 <- block@0, array_length#0 <- block@1) (array_length#1) with array_length#0 in current definition for 1 blocks +debug: Created Phi assignment: let new_items_count#1: uint64 = undefined while trying to resolve 'new_items_count' in block@2 +debug: Added new_items_count#0 to Phi node: let new_items_count#1: uint64 = φ(new_items_count#0 <- block@0) in block@0 +debug: Added new_items_count#0 to Phi node: let new_items_count#1: uint64 = φ(new_items_count#0 <- block@0, new_items_count#0 <- block@1) in block@1 +debug: Replacing trivial Phi node: let new_items_count#1: uint64 = φ(new_items_count#0 <- block@0, new_items_count#0 <- block@1) (new_items_count#1) with new_items_count#0 +debug: Deleting Phi assignment: let new_items_count#1: uint64 = φ(new_items_count#0 <- block@0, new_items_count#0 <- block@1) +debug: Replaced trivial Phi node: let new_items_count#1: uint64 = φ(new_items_count#0 <- block@0, new_items_count#0 <- block@1) (new_items_count#1) with new_items_count#0 in current definition for 1 blocks +debug: Terminated block@2 +debug: Looking for 'write_offset' in an unsealed block creating an incomplete Phi: block@3 +debug: Created Phi assignment: let write_offset#1: uint64 = undefined while trying to resolve 'write_offset' in block@3 +debug: Looking for 'write_end' in an unsealed block creating an incomplete Phi: block@3 +debug: Created Phi assignment: let write_end#1: uint64 = undefined while trying to resolve 'write_end' in block@3 +debug: Terminated block@3 +debug: Sealing block@4 +debug: Looking for 'result' in an unsealed block creating an incomplete Phi: block@3 +debug: Created Phi assignment: let result#2: bytes = undefined while trying to resolve 'result' in block@3 +debug: Looking for 'new_items_bytes' in an unsealed block creating an incomplete Phi: block@3 +debug: Created Phi assignment: let new_items_bytes#1: bytes = undefined while trying to resolve 'new_items_bytes' in block@3 +debug: Looking for 'read_offset' in an unsealed block creating an incomplete Phi: block@3 +debug: Created Phi assignment: let read_offset#1: uint64 = undefined while trying to resolve 'read_offset' in block@3 +debug: Looking for 'read_step' in an unsealed block creating an incomplete Phi: block@3 +debug: Created Phi assignment: let read_step#1: uint64 = undefined while trying to resolve 'read_step' in block@3 +debug: Terminated block@4 +debug: Sealing block@3 +debug: Added write_offset#0 to Phi node: let write_offset#1: uint64 = φ(write_offset#0 <- block@2) in block@2 +debug: Added write_offset#2 to Phi node: let write_offset#1: uint64 = φ(write_offset#0 <- block@2, write_offset#2 <- block@4) in block@4 +debug: Added write_end#0 to Phi node: let write_end#1: uint64 = φ(write_end#0 <- block@2) in block@2 +debug: Added write_end#1 to Phi node: let write_end#1: uint64 = φ(write_end#0 <- block@2, write_end#1 <- block@4) in block@4 +debug: Replacing trivial Phi node: let write_end#1: uint64 = φ(write_end#0 <- block@2, write_end#1 <- block@4) (write_end#1) with write_end#0 +debug: Deleting Phi assignment: let write_end#1: uint64 = φ(write_end#0 <- block@2, write_end#1 <- block@4) +debug: Replaced trivial Phi node: let write_end#1: uint64 = φ(write_end#0 <- block@2, write_end#1 <- block@4) (write_end#1) with write_end#0 in current definition for 2 blocks +debug: Created Phi assignment: let result#4: bytes = undefined while trying to resolve 'result' in block@2 +debug: Added result#0 to Phi node: let result#4: bytes = φ(result#0 <- block@0) in block@0 +debug: Added result#1 to Phi node: let result#4: bytes = φ(result#0 <- block@0, result#1 <- block@1) in block@1 +debug: Added result#4 to Phi node: let result#2: bytes = φ(result#4 <- block@2) in block@2 +debug: Added result#3 to Phi node: let result#2: bytes = φ(result#4 <- block@2, result#3 <- block@4) in block@4 +debug: Created Phi assignment: let new_items_bytes#2: bytes = undefined while trying to resolve 'new_items_bytes' in block@2 +debug: Added new_items_bytes#0 to Phi node: let new_items_bytes#2: bytes = φ(new_items_bytes#0 <- block@0) in block@0 +debug: Added new_items_bytes#0 to Phi node: let new_items_bytes#2: bytes = φ(new_items_bytes#0 <- block@0, new_items_bytes#0 <- block@1) in block@1 +debug: Replacing trivial Phi node: let new_items_bytes#2: bytes = φ(new_items_bytes#0 <- block@0, new_items_bytes#0 <- block@1) (new_items_bytes#2) with new_items_bytes#0 +debug: Deleting Phi assignment: let new_items_bytes#2: bytes = φ(new_items_bytes#0 <- block@0, new_items_bytes#0 <- block@1) +debug: Replaced trivial Phi node: let new_items_bytes#2: bytes = φ(new_items_bytes#0 <- block@0, new_items_bytes#0 <- block@1) (new_items_bytes#2) with new_items_bytes#0 in current definition for 1 blocks +debug: Added new_items_bytes#0 to Phi node: let new_items_bytes#1: bytes = φ(new_items_bytes#0 <- block@2) in block@2 +debug: Added new_items_bytes#1 to Phi node: let new_items_bytes#1: bytes = φ(new_items_bytes#0 <- block@2, new_items_bytes#1 <- block@4) in block@4 +debug: Replacing trivial Phi node: let new_items_bytes#1: bytes = φ(new_items_bytes#0 <- block@2, new_items_bytes#1 <- block@4) (new_items_bytes#1) with new_items_bytes#0 +debug: Deleting Phi assignment: let new_items_bytes#1: bytes = φ(new_items_bytes#0 <- block@2, new_items_bytes#1 <- block@4) +debug: Replaced trivial Phi node: let new_items_bytes#1: bytes = φ(new_items_bytes#0 <- block@2, new_items_bytes#1 <- block@4) (new_items_bytes#1) with new_items_bytes#0 in current definition for 2 blocks +debug: Added read_offset#0 to Phi node: let read_offset#1: uint64 = φ(read_offset#0 <- block@2) in block@2 +debug: Added read_offset#2 to Phi node: let read_offset#1: uint64 = φ(read_offset#0 <- block@2, read_offset#2 <- block@4) in block@4 +debug: Created Phi assignment: let read_step#2: uint64 = undefined while trying to resolve 'read_step' in block@2 +debug: Added read_step#0 to Phi node: let read_step#2: uint64 = φ(read_step#0 <- block@0) in block@0 +debug: Added read_step#0 to Phi node: let read_step#2: uint64 = φ(read_step#0 <- block@0, read_step#0 <- block@1) in block@1 +debug: Replacing trivial Phi node: let read_step#2: uint64 = φ(read_step#0 <- block@0, read_step#0 <- block@1) (read_step#2) with read_step#0 +debug: Deleting Phi assignment: let read_step#2: uint64 = φ(read_step#0 <- block@0, read_step#0 <- block@1) +debug: Replaced trivial Phi node: let read_step#2: uint64 = φ(read_step#0 <- block@0, read_step#0 <- block@1) (read_step#2) with read_step#0 in current definition for 1 blocks +debug: Added read_step#0 to Phi node: let read_step#1: uint64 = φ(read_step#0 <- block@2) in block@2 +debug: Added read_step#1 to Phi node: let read_step#1: uint64 = φ(read_step#0 <- block@2, read_step#1 <- block@4) in block@4 +debug: Replacing trivial Phi node: let read_step#1: uint64 = φ(read_step#0 <- block@2, read_step#1 <- block@4) (read_step#1) with read_step#0 +debug: Deleting Phi assignment: let read_step#1: uint64 = φ(read_step#0 <- block@2, read_step#1 <- block@4) +debug: Replaced trivial Phi node: let read_step#1: uint64 = φ(read_step#0 <- block@2, read_step#1 <- block@4) (read_step#1) with read_step#0 in current definition for 2 blocks +debug: Sealing block@5 +debug: Terminated block@5 +debug: Building IR for function _puya_lib.arc4.dynamic_array_concat_byte_length_head +debug: Sealing block@0 +debug: Terminated block@0 +debug: Building IR for function _puya_lib.arc4.dynamic_array_concat_dynamic_element +debug: Sealing block@0 +debug: Terminated block@0 +debug: Looking for 'value_internal%0' in an unsealed block creating an incomplete Phi: block@1 +debug: Created Phi assignment: let value_internal%0#1: uint64 = undefined while trying to resolve 'value_internal%0' in block@1 +debug: Terminated block@1 +debug: Sealing block@2 +debug: Looking for 'array_head_and_tail' in an unsealed block creating an incomplete Phi: block@1 +debug: Created Phi assignment: let array_head_and_tail#1: bytes = undefined while trying to resolve 'array_head_and_tail' in block@1 +debug: Looking for 'new_head' in an unsealed block creating an incomplete Phi: block@1 +debug: Created Phi assignment: let new_head#1: bytes = undefined while trying to resolve 'new_head' in block@1 +debug: Looking for 'item_offset_adjustment' in an unsealed block creating an incomplete Phi: block@1 +debug: Created Phi assignment: let item_offset_adjustment#1: uint64 = undefined while trying to resolve 'item_offset_adjustment' in block@1 +debug: Terminated block@2 +debug: Sealing block@3 +debug: Terminated block@3 +debug: Sealing block@1 +debug: Added value_internal%0#0 to Phi node: let value_internal%0#1: uint64 = φ(value_internal%0#0 <- block@0) in block@0 +debug: Added value_internal%0#2 to Phi node: let value_internal%0#1: uint64 = φ(value_internal%0#0 <- block@0, value_internal%0#2 <- block@3) in block@3 +debug: Added array_head_and_tail#0 to Phi node: let array_head_and_tail#1: bytes = φ(array_head_and_tail#0 <- block@0) in block@0 +debug: Added array_head_and_tail#1 to Phi node: let array_head_and_tail#1: bytes = φ(array_head_and_tail#0 <- block@0, array_head_and_tail#1 <- block@3) in block@3 +debug: Replacing trivial Phi node: let array_head_and_tail#1: bytes = φ(array_head_and_tail#0 <- block@0, array_head_and_tail#1 <- block@3) (array_head_and_tail#1) with array_head_and_tail#0 +debug: Deleting Phi assignment: let array_head_and_tail#1: bytes = φ(array_head_and_tail#0 <- block@0, array_head_and_tail#1 <- block@3) +debug: Replaced trivial Phi node: let array_head_and_tail#1: bytes = φ(array_head_and_tail#0 <- block@0, array_head_and_tail#1 <- block@3) (array_head_and_tail#1) with array_head_and_tail#0 in current definition for 3 blocks +debug: Added new_head#0 to Phi node: let new_head#1: bytes = φ(new_head#0 <- block@0) in block@0 +debug: Added new_head#2 to Phi node: let new_head#1: bytes = φ(new_head#0 <- block@0, new_head#2 <- block@3) in block@3 +debug: Added item_offset_adjustment#0 to Phi node: let item_offset_adjustment#1: uint64 = φ(item_offset_adjustment#0 <- block@0) in block@0 +debug: Added item_offset_adjustment#1 to Phi node: let item_offset_adjustment#1: uint64 = φ(item_offset_adjustment#0 <- block@0, item_offset_adjustment#1 <- block@3) in block@3 +debug: Replacing trivial Phi node: let item_offset_adjustment#1: uint64 = φ(item_offset_adjustment#0 <- block@0, item_offset_adjustment#1 <- block@3) (item_offset_adjustment#1) with item_offset_adjustment#0 +debug: Deleting Phi assignment: let item_offset_adjustment#1: uint64 = φ(item_offset_adjustment#0 <- block@0, item_offset_adjustment#1 <- block@3) +debug: Replaced trivial Phi node: let item_offset_adjustment#1: uint64 = φ(item_offset_adjustment#0 <- block@0, item_offset_adjustment#1 <- block@3) (item_offset_adjustment#1) with item_offset_adjustment#0 in current definition for 3 blocks +debug: Sealing block@4 +debug: Created Phi assignment: let new_items_count#1: uint64 = undefined while trying to resolve 'new_items_count' in block@1 +debug: Added new_items_count#0 to Phi node: let new_items_count#1: uint64 = φ(new_items_count#0 <- block@0) in block@0 +debug: Added new_items_count#1 to Phi node: let new_items_count#1: uint64 = φ(new_items_count#0 <- block@0, new_items_count#1 <- block@3) in block@3 +debug: Replacing trivial Phi node: let new_items_count#1: uint64 = φ(new_items_count#0 <- block@0, new_items_count#1 <- block@3) (new_items_count#1) with new_items_count#0 +debug: Deleting Phi assignment: let new_items_count#1: uint64 = φ(new_items_count#0 <- block@0, new_items_count#1 <- block@3) +debug: Replaced trivial Phi node: let new_items_count#1: uint64 = φ(new_items_count#0 <- block@0, new_items_count#1 <- block@3) (new_items_count#1) with new_items_count#0 in current definition for 3 blocks +debug: Terminated block@4 +debug: Looking for 'value_internal%1' in an unsealed block creating an incomplete Phi: block@5 +debug: Created Phi assignment: let value_internal%1#1: uint64 = undefined while trying to resolve 'value_internal%1' in block@5 +debug: Terminated block@5 +debug: Sealing block@6 +debug: Looking for 'new_head_and_tail' in an unsealed block creating an incomplete Phi: block@5 +debug: Created Phi assignment: let new_head_and_tail#1: bytes = undefined while trying to resolve 'new_head_and_tail' in block@5 +debug: Looking for 'new_head' in an unsealed block creating an incomplete Phi: block@5 +debug: Created Phi assignment: let new_head#3: bytes = undefined while trying to resolve 'new_head' in block@5 +debug: Looking for 'head_and_tail_length' in an unsealed block creating an incomplete Phi: block@5 +debug: Created Phi assignment: let head_and_tail_length#1: uint64 = undefined while trying to resolve 'head_and_tail_length' in block@5 +debug: Terminated block@6 +debug: Sealing block@7 +debug: Terminated block@7 +debug: Sealing block@5 +debug: Added value_internal%1#0 to Phi node: let value_internal%1#1: uint64 = φ(value_internal%1#0 <- block@4) in block@4 +debug: Added value_internal%1#2 to Phi node: let value_internal%1#1: uint64 = φ(value_internal%1#0 <- block@4, value_internal%1#2 <- block@7) in block@7 +debug: Created Phi assignment: let new_head_and_tail#2: bytes = undefined while trying to resolve 'new_head_and_tail' in block@1 +debug: Added new_head_and_tail#0 to Phi node: let new_head_and_tail#2: bytes = φ(new_head_and_tail#0 <- block@0) in block@0 +debug: Added new_head_and_tail#2 to Phi node: let new_head_and_tail#2: bytes = φ(new_head_and_tail#0 <- block@0, new_head_and_tail#2 <- block@3) in block@3 +debug: Replacing trivial Phi node: let new_head_and_tail#2: bytes = φ(new_head_and_tail#0 <- block@0, new_head_and_tail#2 <- block@3) (new_head_and_tail#2) with new_head_and_tail#0 +debug: Deleting Phi assignment: let new_head_and_tail#2: bytes = φ(new_head_and_tail#0 <- block@0, new_head_and_tail#2 <- block@3) +debug: Replaced trivial Phi node: let new_head_and_tail#2: bytes = φ(new_head_and_tail#0 <- block@0, new_head_and_tail#2 <- block@3) (new_head_and_tail#2) with new_head_and_tail#0 in current definition for 3 blocks +debug: Added new_head_and_tail#0 to Phi node: let new_head_and_tail#1: bytes = φ(new_head_and_tail#0 <- block@4) in block@4 +debug: Added new_head_and_tail#1 to Phi node: let new_head_and_tail#1: bytes = φ(new_head_and_tail#0 <- block@4, new_head_and_tail#1 <- block@7) in block@7 +debug: Replacing trivial Phi node: let new_head_and_tail#1: bytes = φ(new_head_and_tail#0 <- block@4, new_head_and_tail#1 <- block@7) (new_head_and_tail#1) with new_head_and_tail#0 +debug: Deleting Phi assignment: let new_head_and_tail#1: bytes = φ(new_head_and_tail#0 <- block@4, new_head_and_tail#1 <- block@7) +debug: Replaced trivial Phi node: let new_head_and_tail#1: bytes = φ(new_head_and_tail#0 <- block@4, new_head_and_tail#1 <- block@7) (new_head_and_tail#1) with new_head_and_tail#0 in current definition for 3 blocks +debug: Added new_head#1 to Phi node: let new_head#3: bytes = φ(new_head#1 <- block@4) in block@4 +debug: Added new_head#4 to Phi node: let new_head#3: bytes = φ(new_head#1 <- block@4, new_head#4 <- block@7) in block@7 +debug: Added head_and_tail_length#0 to Phi node: let head_and_tail_length#1: uint64 = φ(head_and_tail_length#0 <- block@4) in block@4 +debug: Added head_and_tail_length#1 to Phi node: let head_and_tail_length#1: uint64 = φ(head_and_tail_length#0 <- block@4, head_and_tail_length#1 <- block@7) in block@7 +debug: Replacing trivial Phi node: let head_and_tail_length#1: uint64 = φ(head_and_tail_length#0 <- block@4, head_and_tail_length#1 <- block@7) (head_and_tail_length#1) with head_and_tail_length#0 +debug: Deleting Phi assignment: let head_and_tail_length#1: uint64 = φ(head_and_tail_length#0 <- block@4, head_and_tail_length#1 <- block@7) +debug: Replaced trivial Phi node: let head_and_tail_length#1: uint64 = φ(head_and_tail_length#0 <- block@4, head_and_tail_length#1 <- block@7) (head_and_tail_length#1) with head_and_tail_length#0 in current definition for 3 blocks +debug: Sealing block@8 +debug: Created Phi assignment: let array_items_count#1: uint64 = undefined while trying to resolve 'array_items_count' in block@5 +debug: Created Phi assignment: let array_items_count#2: uint64 = undefined while trying to resolve 'array_items_count' in block@1 +debug: Added array_items_count#0 to Phi node: let array_items_count#2: uint64 = φ(array_items_count#0 <- block@0) in block@0 +debug: Added array_items_count#2 to Phi node: let array_items_count#2: uint64 = φ(array_items_count#0 <- block@0, array_items_count#2 <- block@3) in block@3 +debug: Replacing trivial Phi node: let array_items_count#2: uint64 = φ(array_items_count#0 <- block@0, array_items_count#2 <- block@3) (array_items_count#2) with array_items_count#0 +debug: Deleting Phi assignment: let array_items_count#2: uint64 = φ(array_items_count#0 <- block@0, array_items_count#2 <- block@3) +debug: Replaced trivial Phi node: let array_items_count#2: uint64 = φ(array_items_count#0 <- block@0, array_items_count#2 <- block@3) (array_items_count#2) with array_items_count#0 in current definition for 3 blocks +debug: Added array_items_count#0 to Phi node: let array_items_count#1: uint64 = φ(array_items_count#0 <- block@4) in block@4 +debug: Added array_items_count#1 to Phi node: let array_items_count#1: uint64 = φ(array_items_count#0 <- block@4, array_items_count#1 <- block@7) in block@7 +debug: Replacing trivial Phi node: let array_items_count#1: uint64 = φ(array_items_count#0 <- block@4, array_items_count#1 <- block@7) (array_items_count#1) with array_items_count#0 +debug: Deleting Phi assignment: let array_items_count#1: uint64 = φ(array_items_count#0 <- block@4, array_items_count#1 <- block@7) +debug: Replaced trivial Phi node: let array_items_count#1: uint64 = φ(array_items_count#0 <- block@4, array_items_count#1 <- block@7) (array_items_count#1) with array_items_count#0 in current definition for 3 blocks +debug: Created Phi assignment: let new_items_count#2: uint64 = undefined while trying to resolve 'new_items_count' in block@5 +debug: Added new_items_count#0 to Phi node: let new_items_count#2: uint64 = φ(new_items_count#0 <- block@4) in block@4 +debug: Added new_items_count#2 to Phi node: let new_items_count#2: uint64 = φ(new_items_count#0 <- block@4, new_items_count#2 <- block@7) in block@7 +debug: Replacing trivial Phi node: let new_items_count#2: uint64 = φ(new_items_count#0 <- block@4, new_items_count#2 <- block@7) (new_items_count#2) with new_items_count#0 +debug: Deleting Phi assignment: let new_items_count#2: uint64 = φ(new_items_count#0 <- block@4, new_items_count#2 <- block@7) +debug: Replaced trivial Phi node: let new_items_count#2: uint64 = φ(new_items_count#0 <- block@4, new_items_count#2 <- block@7) (new_items_count#2) with new_items_count#0 in current definition for 3 blocks +debug: Created Phi assignment: let array_head_and_tail#2: bytes = undefined while trying to resolve 'array_head_and_tail' in block@5 +debug: Added array_head_and_tail#0 to Phi node: let array_head_and_tail#2: bytes = φ(array_head_and_tail#0 <- block@4) in block@4 +debug: Added array_head_and_tail#2 to Phi node: let array_head_and_tail#2: bytes = φ(array_head_and_tail#0 <- block@4, array_head_and_tail#2 <- block@7) in block@7 +debug: Replacing trivial Phi node: let array_head_and_tail#2: bytes = φ(array_head_and_tail#0 <- block@4, array_head_and_tail#2 <- block@7) (array_head_and_tail#2) with array_head_and_tail#0 +debug: Deleting Phi assignment: let array_head_and_tail#2: bytes = φ(array_head_and_tail#0 <- block@4, array_head_and_tail#2 <- block@7) +debug: Replaced trivial Phi node: let array_head_and_tail#2: bytes = φ(array_head_and_tail#0 <- block@4, array_head_and_tail#2 <- block@7) (array_head_and_tail#2) with array_head_and_tail#0 in current definition for 3 blocks +debug: Terminated block@8 +debug: Building IR for function _puya_lib.arc4.dynamic_array_replace_byte_length_head +debug: Sealing block@0 +debug: Terminated block@0 +debug: Building IR for function _puya_lib.arc4.dynamic_array_replace_dynamic_element +debug: Sealing block@0 +debug: Terminated block@0 +debug: Building IR for function _puya_lib.arc4.static_array_replace_dynamic_element +debug: Sealing block@0 +debug: Terminated block@0 +debug: Looking for 'value_internal%0' in an unsealed block creating an incomplete Phi: block@1 +debug: Created Phi assignment: let value_internal%0#1: uint64 = undefined while trying to resolve 'value_internal%0' in block@1 +debug: Terminated block@1 +debug: Sealing block@2 +debug: Looking for 'new_head_and_tail' in an unsealed block creating an incomplete Phi: block@1 +debug: Created Phi assignment: let new_head_and_tail#1: bytes = undefined while trying to resolve 'new_head_and_tail' in block@1 +debug: Looking for 'new_item_length' in an unsealed block creating an incomplete Phi: block@1 +debug: Created Phi assignment: let new_item_length#1: uint64 = undefined while trying to resolve 'new_item_length' in block@1 +debug: Looking for 'original_item_length' in an unsealed block creating an incomplete Phi: block@1 +debug: Created Phi assignment: let original_item_length#1: uint64 = undefined while trying to resolve 'original_item_length' in block@1 +debug: Terminated block@2 +debug: Sealing block@3 +debug: Terminated block@3 +debug: Sealing block@1 +debug: Added value_internal%0#0 to Phi node: let value_internal%0#1: uint64 = φ(value_internal%0#0 <- block@0) in block@0 +debug: Added value_internal%0#2 to Phi node: let value_internal%0#1: uint64 = φ(value_internal%0#0 <- block@0, value_internal%0#2 <- block@3) in block@3 +debug: Added new_head_and_tail#0 to Phi node: let new_head_and_tail#1: bytes = φ(new_head_and_tail#0 <- block@0) in block@0 +debug: Added new_head_and_tail#2 to Phi node: let new_head_and_tail#1: bytes = φ(new_head_and_tail#0 <- block@0, new_head_and_tail#2 <- block@3) in block@3 +debug: Added new_item_length#0 to Phi node: let new_item_length#1: uint64 = φ(new_item_length#0 <- block@0) in block@0 +debug: Added new_item_length#1 to Phi node: let new_item_length#1: uint64 = φ(new_item_length#0 <- block@0, new_item_length#1 <- block@3) in block@3 +debug: Replacing trivial Phi node: let new_item_length#1: uint64 = φ(new_item_length#0 <- block@0, new_item_length#1 <- block@3) (new_item_length#1) with new_item_length#0 +debug: Deleting Phi assignment: let new_item_length#1: uint64 = φ(new_item_length#0 <- block@0, new_item_length#1 <- block@3) +debug: Replaced trivial Phi node: let new_item_length#1: uint64 = φ(new_item_length#0 <- block@0, new_item_length#1 <- block@3) (new_item_length#1) with new_item_length#0 in current definition for 3 blocks +debug: Added original_item_length#0 to Phi node: let original_item_length#1: uint64 = φ(original_item_length#0 <- block@0) in block@0 +debug: Added original_item_length#1 to Phi node: let original_item_length#1: uint64 = φ(original_item_length#0 <- block@0, original_item_length#1 <- block@3) in block@3 +debug: Replacing trivial Phi node: let original_item_length#1: uint64 = φ(original_item_length#0 <- block@0, original_item_length#1 <- block@3) (original_item_length#1) with original_item_length#0 +debug: Deleting Phi assignment: let original_item_length#1: uint64 = φ(original_item_length#0 <- block@0, original_item_length#1 <- block@3) +debug: Replaced trivial Phi node: let original_item_length#1: uint64 = φ(original_item_length#0 <- block@0, original_item_length#1 <- block@3) (original_item_length#1) with original_item_length#0 in current definition for 3 blocks +debug: Sealing block@4 +debug: Terminated block@4 +debug: Building IR for function _puya_lib.arc4.static_array_replace_byte_length_head +debug: Sealing block@0 +debug: Terminated block@0 +debug: Building IR for function _puya_lib.arc4.recalculate_head_for_elements_with_byte_length_head +debug: Sealing block@0 +debug: Terminated block@0 +debug: Looking for 'value_internal%0' in an unsealed block creating an incomplete Phi: block@1 +debug: Created Phi assignment: let value_internal%0#1: uint64 = undefined while trying to resolve 'value_internal%0' in block@1 +debug: Terminated block@1 +debug: Sealing block@2 +debug: Looking for 'tail_offset' in an unsealed block creating an incomplete Phi: block@1 +debug: Created Phi assignment: let tail_offset#1: uint64 = undefined while trying to resolve 'tail_offset' in block@1 +debug: Looking for 'array_head_and_tail' in an unsealed block creating an incomplete Phi: block@1 +debug: Created Phi assignment: let array_head_and_tail#1: bytes = undefined while trying to resolve 'array_head_and_tail' in block@1 +debug: Terminated block@2 +debug: Sealing block@3 +debug: Terminated block@3 +debug: Sealing block@1 +debug: Added value_internal%0#0 to Phi node: let value_internal%0#1: uint64 = φ(value_internal%0#0 <- block@0) in block@0 +debug: Added value_internal%0#2 to Phi node: let value_internal%0#1: uint64 = φ(value_internal%0#0 <- block@0, value_internal%0#2 <- block@3) in block@3 +debug: Added tail_offset#0 to Phi node: let tail_offset#1: uint64 = φ(tail_offset#0 <- block@0) in block@0 +debug: Added tail_offset#2 to Phi node: let tail_offset#1: uint64 = φ(tail_offset#0 <- block@0, tail_offset#2 <- block@3) in block@3 +debug: Added array_head_and_tail#0 to Phi node: let array_head_and_tail#1: bytes = φ(array_head_and_tail#0 <- block@0) in block@0 +debug: Added array_head_and_tail#2 to Phi node: let array_head_and_tail#1: bytes = φ(array_head_and_tail#0 <- block@0, array_head_and_tail#2 <- block@3) in block@3 +debug: Sealing block@4 +debug: Terminated block@4 +debug: Building IR for function test_cases.structure_methods.contract.ARC4TestStruct.return_value_times +debug: Sealing block@0 +debug: Terminated block@0 +debug: Building IR for function test_cases.structure_methods.contract.ARC4TestStruct.return1 +debug: Sealing block@0 +debug: Terminated block@0 +debug: Building IR for function test_cases.structure_methods.contract.TestStruct.return_value_times +debug: Sealing block@0 +debug: Terminated block@0 +debug: Building IR for function test_cases.structure_methods.contract.TestStruct.return1 +debug: Sealing block@0 +debug: Terminated block@0 +debug: Building IR for function test_cases.structure_methods.contract.TestNamedTuple.return_value_times +debug: Sealing block@0 +debug: Terminated block@0 +debug: Building IR for function test_cases.structure_methods.contract.TestNamedTuple.return1 +debug: Sealing block@0 +debug: Terminated block@0 +debug: Building IR for function test_cases.structure_methods.contract.GroupedMethods.never_inlined_usually_inlined +debug: Sealing block@0 +debug: Terminated block@0 +debug: Building IR for function test_cases.structure_methods.contract.GroupedMethods.always_inlined_not_usually_inlined +debug: Sealing block@0 +debug: Terminated block@0 +debug: Building IR for function test_cases.structure_methods.contract.GroupedMethods.usually_inlined +debug: Sealing block@0 +debug: Terminated block@0 +debug: Building IR for function test_cases.structure_methods.contract.GroupedMethods.not_usually_inlined +debug: Sealing block@0 +debug: Terminated block@0 +debug: Building IR for function test_cases.structure_methods.contract.TestContract.__puya_arc4_router__ +debug: Sealing block@0 +debug: Terminated block@0 +debug: Sealing block@1 +debug: Terminated block@1 +debug: Sealing block@2 +debug: Terminated block@2 +debug: Sealing block@3 +debug: Terminated block@3 +debug: Sealing block@4 +debug: Terminated block@4 +debug: Sealing block@5 +debug: Terminated block@5 +debug: Building IR for function test_cases.structure_methods.contract.TestContract.test[routing] +debug: Sealing block@0 +debug: Terminated block@0 +debug: Building IR for function test_cases.structure_methods.contract.TestContract.test +debug: Sealing block@0 +debug: Terminated block@0 +debug: Building IR for function test_cases.structure_methods.contract.TestContract.__algopy_default_create +debug: Sealing block@0 +debug: Terminated block@0 +debug: Building IR for function algopy.arc4.ARC4Contract.approval_program +debug: Sealing block@0 +debug: Terminated block@0 +debug: Building IR for function algopy.arc4.ARC4Contract.clear_state_program +debug: Sealing block@0 +debug: Terminated block@0 +debug: Building IR for function algopy._contract.Contract.__init__ +debug: Sealing block@0 +debug: Terminated block@0 +debug: Building IR for function algopy.arc4.ARC4Contract.approval_program +debug: Sealing block@0 +debug: Terminated block@0 +debug: removing unused subroutine _puya_lib.util.ensure_budget +debug: removing unused subroutine _puya_lib.bytes_.is_substring +debug: removing unused subroutine _puya_lib.arc4.dynamic_array_pop_bit +debug: removing unused subroutine _puya_lib.arc4.dynamic_array_pop_fixed_size +debug: removing unused subroutine _puya_lib.arc4.dynamic_array_pop_byte_length_head +debug: removing unused subroutine _puya_lib.arc4.dynamic_array_pop_dynamic_element +debug: removing unused subroutine _puya_lib.arc4.dynamic_array_concat_bits +debug: removing unused subroutine _puya_lib.arc4.dynamic_array_concat_byte_length_head +debug: removing unused subroutine _puya_lib.arc4.dynamic_array_concat_dynamic_element +debug: removing unused subroutine _puya_lib.arc4.dynamic_array_replace_byte_length_head +debug: removing unused subroutine _puya_lib.arc4.dynamic_array_replace_dynamic_element +debug: removing unused subroutine _puya_lib.arc4.static_array_replace_dynamic_element +debug: removing unused subroutine _puya_lib.arc4.static_array_replace_byte_length_head +debug: removing unused subroutine _puya_lib.arc4.recalculate_head_for_elements_with_byte_length_head +debug: removing unused subroutine algopy.arc4.ARC4Contract.approval_program +debug: removing unused subroutine algopy.arc4.ARC4Contract.clear_state_program +debug: removing unused subroutine algopy._contract.Contract.__init__ +debug: Building IR for function algopy.arc4.ARC4Contract.clear_state_program +debug: Sealing block@0 +debug: Terminated block@0 +debug: removing unused subroutine _puya_lib.util.ensure_budget +debug: removing unused subroutine _puya_lib.bytes_.is_substring +debug: removing unused subroutine _puya_lib.arc4.dynamic_array_pop_bit +debug: removing unused subroutine _puya_lib.arc4.dynamic_array_pop_fixed_size +debug: removing unused subroutine _puya_lib.arc4.dynamic_array_pop_byte_length_head +debug: removing unused subroutine _puya_lib.arc4.dynamic_array_pop_dynamic_element +debug: removing unused subroutine _puya_lib.arc4.dynamic_array_concat_bits +debug: removing unused subroutine _puya_lib.arc4.dynamic_array_concat_byte_length_head +debug: removing unused subroutine _puya_lib.arc4.dynamic_array_concat_dynamic_element +debug: removing unused subroutine _puya_lib.arc4.dynamic_array_replace_byte_length_head +debug: removing unused subroutine _puya_lib.arc4.dynamic_array_replace_dynamic_element +debug: removing unused subroutine _puya_lib.arc4.static_array_replace_dynamic_element +debug: removing unused subroutine _puya_lib.arc4.static_array_replace_byte_length_head +debug: removing unused subroutine _puya_lib.arc4.recalculate_head_for_elements_with_byte_length_head +debug: removing unused subroutine test_cases.structure_methods.contract.ARC4TestStruct.return_value_times +debug: removing unused subroutine test_cases.structure_methods.contract.ARC4TestStruct.return1 +debug: removing unused subroutine test_cases.structure_methods.contract.TestStruct.return_value_times +debug: removing unused subroutine test_cases.structure_methods.contract.TestStruct.return1 +debug: removing unused subroutine test_cases.structure_methods.contract.TestNamedTuple.return_value_times +debug: removing unused subroutine test_cases.structure_methods.contract.TestNamedTuple.return1 +debug: removing unused subroutine test_cases.structure_methods.contract.GroupedMethods.never_inlined_usually_inlined +debug: removing unused subroutine test_cases.structure_methods.contract.GroupedMethods.always_inlined_not_usually_inlined +debug: removing unused subroutine test_cases.structure_methods.contract.GroupedMethods.usually_inlined +debug: removing unused subroutine test_cases.structure_methods.contract.GroupedMethods.not_usually_inlined +debug: removing unused subroutine test_cases.structure_methods.contract.TestContract.__puya_arc4_router__ +debug: removing unused subroutine test_cases.structure_methods.contract.TestContract.test[routing] +debug: removing unused subroutine test_cases.structure_methods.contract.TestContract.test +debug: removing unused subroutine test_cases.structure_methods.contract.TestContract.__algopy_default_create +debug: removing unused subroutine algopy.arc4.ARC4Contract.approval_program +debug: removing unused subroutine algopy.arc4.ARC4Contract.clear_state_program +debug: removing unused subroutine algopy._contract.Contract.__init__ +debug: Output IR to structure_methods/out/TestContract.ir/TestContract.approval.000.ssa.ir +debug: Output IR to structure_methods/out/TestContract.ir/TestContract.clear.000.ssa.ir +debug: optimizing approval program of test_cases.structure_methods.contract.TestContract at level 1 +debug: Begin optimization pass 1/100 +debug: marking trivial method test_cases.structure_methods.contract.ARC4TestStruct.return1 as inlineable +debug: marking trivial method test_cases.structure_methods.contract.TestStruct.return1 as inlineable +debug: marking trivial method test_cases.structure_methods.contract.TestNamedTuple.return1 as inlineable +debug: marking single-use function test_cases.structure_methods.contract.TestContract.test for inlining +debug: Optimizing subroutine algopy.arc4.ARC4Contract.approval_program +debug: Optimizer: Perform Subroutine Inlining +debug: inlining call to test_cases.structure_methods.contract.TestContract.__puya_arc4_router__ in algopy.arc4.ARC4Contract.approval_program +debug: Optimizer: Split Parallel Copies +debug: Optimizer: Constant Replacer +debug: Optimizer: Copy Propagation +debug: Optimizer: Elide Itxn Field Calls +debug: Optimizer: Remove Unused Variables +debug: Optimizer: Intrinsic Simplifier +debug: Simplified (== tmp%3#0 NoOp) to (! tmp%3#0) +debug: Simplified (&& tmp%4#0 tmp%6#0) to (&& tmp%4#0 tmp%5#0) +debug: Simplified (== tmp%8#0 NoOp) to (! tmp%8#0) +debug: Simplified (== tmp%10#0 0u) to (! tmp%10#0) +debug: Optimizer: Inner Txn Field Replacer +debug: Optimizer: Replace Compiled References +debug: Optimizer: Simplify Control Ops +debug: simplifying exit 0 to err +debug: simplified terminator of block@6 from exit 0u to fail +debug: Optimizer: Merge Blocks +debug: Replaced predecessor block@1 with block@0 in block@5 +debug: Replaced predecessor block@1 with block@0 in block@2 +debug: Merged linear block@1 into block@0 +debug: Merged linear block@6 into block@4 +debug: Optimizer: Remove Linear Jumps +debug: Optimizer: Remove Unreachable Blocks +debug: Removing unreachable block: block@7 +debug: Optimizer: Repeated Expression Elimination +debug: Optimizer: Encode Decode Pair Elimination +debug: Optimizer: Merge Chained Aggregate Reads +debug: Optimizer: Replace Aggregate Box Ops +debug: Optimizer: Minimize Box Exist Asserts +debug: Optimizer: Constant Reads And Unobserved Writes Elimination +debug: Optimizing subroutine test_cases.structure_methods.contract.ARC4TestStruct.return_value_times +debug: Optimizer: Perform Subroutine Inlining +debug: Optimizer: Split Parallel Copies +debug: Optimizer: Constant Replacer +debug: Optimizer: Copy Propagation +debug: Found equivalence set: self#0, self%out#0 +debug: selected self#0 from equivalence set +debug: Optimizer: Elide Itxn Field Calls +debug: Optimizer: Remove Unused Variables +debug: Removing unused variable self%is_original#0 +debug: Optimizer: Intrinsic Simplifier +debug: Optimizer: Inner Txn Field Replacer +debug: Optimizer: Replace Compiled References +debug: Optimizer: Simplify Control Ops +debug: Optimizer: Merge Blocks +debug: Optimizer: Remove Linear Jumps +debug: Optimizer: Remove Unreachable Blocks +debug: Optimizer: Repeated Expression Elimination +debug: Optimizer: Encode Decode Pair Elimination +debug: Optimizer: Merge Chained Aggregate Reads +debug: Optimizer: Replace Aggregate Box Ops +debug: Optimizer: Minimize Box Exist Asserts +debug: Optimizer: Constant Reads And Unobserved Writes Elimination +debug: Optimizing subroutine test_cases.structure_methods.contract.ARC4TestStruct.return1 +debug: Optimizer: Perform Subroutine Inlining +debug: Optimizer: Split Parallel Copies +debug: Optimizer: Constant Replacer +debug: Optimizer: Copy Propagation +debug: Optimizer: Elide Itxn Field Calls +debug: Optimizer: Remove Unused Variables +debug: Optimizer: Intrinsic Simplifier +debug: Optimizer: Inner Txn Field Replacer +debug: Optimizer: Replace Compiled References +debug: Optimizer: Simplify Control Ops +debug: Optimizer: Merge Blocks +debug: Optimizer: Remove Linear Jumps +debug: Optimizer: Remove Unreachable Blocks +debug: Optimizer: Repeated Expression Elimination +debug: Optimizer: Encode Decode Pair Elimination +debug: Optimizer: Merge Chained Aggregate Reads +debug: Optimizer: Replace Aggregate Box Ops +debug: Optimizer: Minimize Box Exist Asserts +debug: Optimizer: Constant Reads And Unobserved Writes Elimination +debug: Optimizing subroutine test_cases.structure_methods.contract.TestStruct.return_value_times +debug: Optimizer: Perform Subroutine Inlining +debug: Optimizer: Split Parallel Copies +debug: Optimizer: Constant Replacer +debug: Optimizer: Copy Propagation +debug: Found equivalence set: self#0, self%out#0 +debug: selected self#0 from equivalence set +debug: Optimizer: Elide Itxn Field Calls +debug: Optimizer: Remove Unused Variables +debug: Removing unused variable self%is_original#0 +debug: Optimizer: Intrinsic Simplifier +debug: Optimizer: Inner Txn Field Replacer +debug: Optimizer: Replace Compiled References +debug: Optimizer: Simplify Control Ops +debug: Optimizer: Merge Blocks +debug: Optimizer: Remove Linear Jumps +debug: Optimizer: Remove Unreachable Blocks +debug: Optimizer: Repeated Expression Elimination +debug: Optimizer: Encode Decode Pair Elimination +debug: Optimizer: Merge Chained Aggregate Reads +debug: Optimizer: Replace Aggregate Box Ops +debug: Optimizer: Minimize Box Exist Asserts +debug: Optimizer: Constant Reads And Unobserved Writes Elimination +debug: Optimizing subroutine test_cases.structure_methods.contract.TestStruct.return1 +debug: Optimizer: Perform Subroutine Inlining +debug: Optimizer: Split Parallel Copies +debug: Optimizer: Constant Replacer +debug: Optimizer: Copy Propagation +debug: Optimizer: Elide Itxn Field Calls +debug: Optimizer: Remove Unused Variables +debug: Optimizer: Intrinsic Simplifier +debug: Optimizer: Inner Txn Field Replacer +debug: Optimizer: Replace Compiled References +debug: Optimizer: Simplify Control Ops +debug: Optimizer: Merge Blocks +debug: Optimizer: Remove Linear Jumps +debug: Optimizer: Remove Unreachable Blocks +debug: Optimizer: Repeated Expression Elimination +debug: Optimizer: Encode Decode Pair Elimination +debug: Optimizer: Merge Chained Aggregate Reads +debug: Optimizer: Replace Aggregate Box Ops +debug: Optimizer: Minimize Box Exist Asserts +debug: Optimizer: Constant Reads And Unobserved Writes Elimination +debug: Optimizing subroutine test_cases.structure_methods.contract.TestNamedTuple.return_value_times +debug: Optimizer: Perform Subroutine Inlining +debug: Optimizer: Split Parallel Copies +debug: Optimizer: Constant Replacer +debug: Optimizer: Copy Propagation +debug: Optimizer: Elide Itxn Field Calls +debug: Optimizer: Remove Unused Variables +debug: Optimizer: Intrinsic Simplifier +debug: Optimizer: Inner Txn Field Replacer +debug: Optimizer: Replace Compiled References +debug: Optimizer: Simplify Control Ops +debug: Optimizer: Merge Blocks +debug: Optimizer: Remove Linear Jumps +debug: Optimizer: Remove Unreachable Blocks +debug: Optimizer: Repeated Expression Elimination +debug: Optimizer: Encode Decode Pair Elimination +debug: Optimizer: Merge Chained Aggregate Reads +debug: Optimizer: Replace Aggregate Box Ops +debug: Optimizer: Minimize Box Exist Asserts +debug: Optimizer: Constant Reads And Unobserved Writes Elimination +debug: Optimizing subroutine test_cases.structure_methods.contract.TestNamedTuple.return1 +debug: Optimizer: Perform Subroutine Inlining +debug: Optimizer: Split Parallel Copies +debug: Optimizer: Constant Replacer +debug: Optimizer: Copy Propagation +debug: Optimizer: Elide Itxn Field Calls +debug: Optimizer: Remove Unused Variables +debug: Optimizer: Intrinsic Simplifier +debug: Optimizer: Inner Txn Field Replacer +debug: Optimizer: Replace Compiled References +debug: Optimizer: Simplify Control Ops +debug: Optimizer: Merge Blocks +debug: Optimizer: Remove Linear Jumps +debug: Optimizer: Remove Unreachable Blocks +debug: Optimizer: Repeated Expression Elimination +debug: Optimizer: Encode Decode Pair Elimination +debug: Optimizer: Merge Chained Aggregate Reads +debug: Optimizer: Replace Aggregate Box Ops +debug: Optimizer: Minimize Box Exist Asserts +debug: Optimizer: Constant Reads And Unobserved Writes Elimination +debug: Optimizing subroutine test_cases.structure_methods.contract.GroupedMethods.never_inlined_usually_inlined +debug: Optimizer: Perform Subroutine Inlining +debug: Optimizer: Split Parallel Copies +debug: Optimizer: Constant Replacer +debug: Optimizer: Copy Propagation +debug: Optimizer: Elide Itxn Field Calls +debug: Optimizer: Remove Unused Variables +debug: Optimizer: Intrinsic Simplifier +debug: Optimizer: Inner Txn Field Replacer +debug: Optimizer: Replace Compiled References +debug: Optimizer: Simplify Control Ops +debug: Optimizer: Merge Blocks +debug: Optimizer: Remove Linear Jumps +debug: Optimizer: Remove Unreachable Blocks +debug: Optimizer: Repeated Expression Elimination +debug: Optimizer: Encode Decode Pair Elimination +debug: Optimizer: Merge Chained Aggregate Reads +debug: Optimizer: Replace Aggregate Box Ops +debug: Optimizer: Minimize Box Exist Asserts +debug: Optimizer: Constant Reads And Unobserved Writes Elimination +debug: Optimizing subroutine test_cases.structure_methods.contract.GroupedMethods.always_inlined_not_usually_inlined +debug: Optimizer: Perform Subroutine Inlining +debug: Optimizer: Split Parallel Copies +debug: Optimizer: Constant Replacer +debug: Optimizer: Copy Propagation +debug: Optimizer: Elide Itxn Field Calls +debug: Optimizer: Remove Unused Variables +debug: Optimizer: Intrinsic Simplifier +debug: Optimizer: Inner Txn Field Replacer +debug: Optimizer: Replace Compiled References +debug: Optimizer: Simplify Control Ops +debug: Optimizer: Merge Blocks +debug: Optimizer: Remove Linear Jumps +debug: Optimizer: Remove Unreachable Blocks +debug: Optimizer: Repeated Expression Elimination +debug: Replacing redundant declaration let tmp%2#0: Encoded(uint64) = bytes_encode(v#0) with copy of existing registers [Register(source_location=structure_methods/contract.py:46:33-47, ir_type=Encoded(uint64), name='tmp%0', version=0)] +debug: Replacing redundant declaration let tmp%4#0: Encoded(uint64) = bytes_encode(v#0) with copy of existing registers [Register(source_location=structure_methods/contract.py:46:33-47, ir_type=Encoded(uint64), name='tmp%0', version=0)] +debug: Replacing redundant declaration let tmp%6#0: Encoded(uint64) = bytes_encode(v#0) with copy of existing registers [Register(source_location=structure_methods/contract.py:46:33-47, ir_type=Encoded(uint64), name='tmp%0', version=0)] +debug: Replacing redundant declaration let tmp%8#0: Encoded(uint64) = bytes_encode(v#0) with copy of existing registers [Register(source_location=structure_methods/contract.py:46:33-47, ir_type=Encoded(uint64), name='tmp%0', version=0)] +debug: Replacing redundant declaration let tmp%10#0: Encoded(uint64) = bytes_encode(v#0) with copy of existing registers [Register(source_location=structure_methods/contract.py:46:33-47, ir_type=Encoded(uint64), name='tmp%0', version=0)] +debug: Replacing redundant declaration let tmp%12#0: Encoded(uint64) = bytes_encode(v#0) with copy of existing registers [Register(source_location=structure_methods/contract.py:46:33-47, ir_type=Encoded(uint64), name='tmp%0', version=0)] +debug: Replacing redundant declaration let tmp%14#0: Encoded(uint64) = bytes_encode(v#0) with copy of existing registers [Register(source_location=structure_methods/contract.py:46:33-47, ir_type=Encoded(uint64), name='tmp%0', version=0)] +debug: Found equivalence set: tmp%0#0, tmp%2#0, tmp%4#0, tmp%6#0, tmp%8#0, tmp%10#0, tmp%12#0, tmp%14#0 +debug: selected tmp%0#0 from equivalence set +debug: Copy propagation made 7 modifications +debug: Replacing redundant declaration let tmp%3#0: Encoded(uint64) = bytes_encode<(uint64)>(tmp%0#0) with copy of existing registers [Register(source_location=structure_methods/contract.py:46:18-48, ir_type=Encoded(uint64), name='tmp%1', version=0)] +debug: Replacing redundant declaration let tmp%5#0: Encoded(uint64) = bytes_encode<(uint64)>(tmp%0#0) with copy of existing registers [Register(source_location=structure_methods/contract.py:46:18-48, ir_type=Encoded(uint64), name='tmp%1', version=0)] +debug: Replacing redundant declaration let tmp%7#0: Encoded(uint64) = bytes_encode<(uint64)>(tmp%0#0) with copy of existing registers [Register(source_location=structure_methods/contract.py:46:18-48, ir_type=Encoded(uint64), name='tmp%1', version=0)] +debug: Replacing redundant declaration let tmp%9#0: Encoded(uint64) = bytes_encode<(uint64)>(tmp%0#0) with copy of existing registers [Register(source_location=structure_methods/contract.py:46:18-48, ir_type=Encoded(uint64), name='tmp%1', version=0)] +debug: Replacing redundant declaration let tmp%11#0: Encoded(uint64) = bytes_encode<(uint64)>(tmp%0#0) with copy of existing registers [Register(source_location=structure_methods/contract.py:46:18-48, ir_type=Encoded(uint64), name='tmp%1', version=0)] +debug: Replacing redundant declaration let tmp%13#0: Encoded(uint64) = bytes_encode<(uint64)>(tmp%0#0) with copy of existing registers [Register(source_location=structure_methods/contract.py:46:18-48, ir_type=Encoded(uint64), name='tmp%1', version=0)] +debug: Replacing redundant declaration let tmp%15#0: Encoded(uint64) = bytes_encode<(uint64)>(tmp%0#0) with copy of existing registers [Register(source_location=structure_methods/contract.py:46:18-48, ir_type=Encoded(uint64), name='tmp%1', version=0)] +debug: Found equivalence set: tmp%1#0, tmp%3#0, tmp%5#0, tmp%7#0, tmp%9#0, tmp%11#0, tmp%13#0, tmp%15#0 +debug: selected tmp%1#0 from equivalence set +debug: Copy propagation made 7 modifications +debug: Replacing redundant declaration let event%1#0: bytes = (concat method "ARC4TestStruct(uint64)" tmp%1#0) with copy of existing registers [Register(source_location=structure_methods/contract.py:46:8-49, ir_type=bytes, name='event%0', version=0)] +debug: Replacing redundant declaration let event%2#0: bytes = (concat method "ARC4TestStruct(uint64)" tmp%1#0) with copy of existing registers [Register(source_location=structure_methods/contract.py:46:8-49, ir_type=bytes, name='event%0', version=0)] +debug: Replacing redundant declaration let event%3#0: bytes = (concat method "ARC4TestStruct(uint64)" tmp%1#0) with copy of existing registers [Register(source_location=structure_methods/contract.py:46:8-49, ir_type=bytes, name='event%0', version=0)] +debug: Replacing redundant declaration let event%4#0: bytes = (concat method "ARC4TestStruct(uint64)" tmp%1#0) with copy of existing registers [Register(source_location=structure_methods/contract.py:46:8-49, ir_type=bytes, name='event%0', version=0)] +debug: Replacing redundant declaration let event%5#0: bytes = (concat method "ARC4TestStruct(uint64)" tmp%1#0) with copy of existing registers [Register(source_location=structure_methods/contract.py:46:8-49, ir_type=bytes, name='event%0', version=0)] +debug: Replacing redundant declaration let event%6#0: bytes = (concat method "ARC4TestStruct(uint64)" tmp%1#0) with copy of existing registers [Register(source_location=structure_methods/contract.py:46:8-49, ir_type=bytes, name='event%0', version=0)] +debug: Replacing redundant declaration let event%7#0: bytes = (concat method "ARC4TestStruct(uint64)" tmp%1#0) with copy of existing registers [Register(source_location=structure_methods/contract.py:46:8-49, ir_type=bytes, name='event%0', version=0)] +debug: Found equivalence set: event%0#0, event%1#0, event%2#0, event%3#0, event%4#0, event%5#0, event%6#0, event%7#0 +debug: selected event%0#0 from equivalence set +debug: Copy propagation made 7 modifications +debug: Optimizer: Encode Decode Pair Elimination +debug: Optimizer: Merge Chained Aggregate Reads +debug: Optimizer: Replace Aggregate Box Ops +debug: Optimizer: Minimize Box Exist Asserts +debug: Optimizer: Constant Reads And Unobserved Writes Elimination +debug: Optimizing subroutine test_cases.structure_methods.contract.GroupedMethods.usually_inlined +debug: Optimizer: Perform Subroutine Inlining +debug: Optimizer: Split Parallel Copies +debug: Optimizer: Constant Replacer +debug: Optimizer: Copy Propagation +debug: Optimizer: Elide Itxn Field Calls +debug: Optimizer: Remove Unused Variables +debug: Optimizer: Intrinsic Simplifier +debug: Optimizer: Inner Txn Field Replacer +debug: Optimizer: Replace Compiled References +debug: Optimizer: Simplify Control Ops +debug: Optimizer: Merge Blocks +debug: Optimizer: Remove Linear Jumps +debug: Optimizer: Remove Unreachable Blocks +debug: Optimizer: Repeated Expression Elimination +debug: Optimizer: Encode Decode Pair Elimination +debug: Optimizer: Merge Chained Aggregate Reads +debug: Optimizer: Replace Aggregate Box Ops +debug: Optimizer: Minimize Box Exist Asserts +debug: Optimizer: Constant Reads And Unobserved Writes Elimination +debug: Optimizing subroutine test_cases.structure_methods.contract.GroupedMethods.not_usually_inlined +debug: Optimizer: Perform Subroutine Inlining +debug: Optimizer: Split Parallel Copies +debug: Optimizer: Constant Replacer +debug: Optimizer: Copy Propagation +debug: Optimizer: Elide Itxn Field Calls +debug: Optimizer: Remove Unused Variables +debug: Optimizer: Intrinsic Simplifier +debug: Optimizer: Inner Txn Field Replacer +debug: Optimizer: Replace Compiled References +debug: Optimizer: Simplify Control Ops +debug: Optimizer: Merge Blocks +debug: Optimizer: Remove Linear Jumps +debug: Optimizer: Remove Unreachable Blocks +debug: Optimizer: Repeated Expression Elimination +debug: Replacing redundant declaration let tmp%2#0: Encoded(uint64) = bytes_encode(v#0) with copy of existing registers [Register(source_location=structure_methods/contract.py:59:33-47, ir_type=Encoded(uint64), name='tmp%0', version=0)] +debug: Replacing redundant declaration let tmp%4#0: Encoded(uint64) = bytes_encode(v#0) with copy of existing registers [Register(source_location=structure_methods/contract.py:59:33-47, ir_type=Encoded(uint64), name='tmp%0', version=0)] +debug: Replacing redundant declaration let tmp%6#0: Encoded(uint64) = bytes_encode(v#0) with copy of existing registers [Register(source_location=structure_methods/contract.py:59:33-47, ir_type=Encoded(uint64), name='tmp%0', version=0)] +debug: Replacing redundant declaration let tmp%8#0: Encoded(uint64) = bytes_encode(v#0) with copy of existing registers [Register(source_location=structure_methods/contract.py:59:33-47, ir_type=Encoded(uint64), name='tmp%0', version=0)] +debug: Replacing redundant declaration let tmp%10#0: Encoded(uint64) = bytes_encode(v#0) with copy of existing registers [Register(source_location=structure_methods/contract.py:59:33-47, ir_type=Encoded(uint64), name='tmp%0', version=0)] +debug: Replacing redundant declaration let tmp%12#0: Encoded(uint64) = bytes_encode(v#0) with copy of existing registers [Register(source_location=structure_methods/contract.py:59:33-47, ir_type=Encoded(uint64), name='tmp%0', version=0)] +debug: Replacing redundant declaration let tmp%14#0: Encoded(uint64) = bytes_encode(v#0) with copy of existing registers [Register(source_location=structure_methods/contract.py:59:33-47, ir_type=Encoded(uint64), name='tmp%0', version=0)] +debug: Found equivalence set: tmp%0#0, tmp%2#0, tmp%4#0, tmp%6#0, tmp%8#0, tmp%10#0, tmp%12#0, tmp%14#0 +debug: selected tmp%0#0 from equivalence set +debug: Copy propagation made 7 modifications +debug: Replacing redundant declaration let tmp%3#0: Encoded(uint64) = bytes_encode<(uint64)>(tmp%0#0) with copy of existing registers [Register(source_location=structure_methods/contract.py:59:18-48, ir_type=Encoded(uint64), name='tmp%1', version=0)] +debug: Replacing redundant declaration let tmp%5#0: Encoded(uint64) = bytes_encode<(uint64)>(tmp%0#0) with copy of existing registers [Register(source_location=structure_methods/contract.py:59:18-48, ir_type=Encoded(uint64), name='tmp%1', version=0)] +debug: Replacing redundant declaration let tmp%7#0: Encoded(uint64) = bytes_encode<(uint64)>(tmp%0#0) with copy of existing registers [Register(source_location=structure_methods/contract.py:59:18-48, ir_type=Encoded(uint64), name='tmp%1', version=0)] +debug: Replacing redundant declaration let tmp%9#0: Encoded(uint64) = bytes_encode<(uint64)>(tmp%0#0) with copy of existing registers [Register(source_location=structure_methods/contract.py:59:18-48, ir_type=Encoded(uint64), name='tmp%1', version=0)] +debug: Replacing redundant declaration let tmp%11#0: Encoded(uint64) = bytes_encode<(uint64)>(tmp%0#0) with copy of existing registers [Register(source_location=structure_methods/contract.py:59:18-48, ir_type=Encoded(uint64), name='tmp%1', version=0)] +debug: Replacing redundant declaration let tmp%13#0: Encoded(uint64) = bytes_encode<(uint64)>(tmp%0#0) with copy of existing registers [Register(source_location=structure_methods/contract.py:59:18-48, ir_type=Encoded(uint64), name='tmp%1', version=0)] +debug: Replacing redundant declaration let tmp%15#0: Encoded(uint64) = bytes_encode<(uint64)>(tmp%0#0) with copy of existing registers [Register(source_location=structure_methods/contract.py:59:18-48, ir_type=Encoded(uint64), name='tmp%1', version=0)] +debug: Found equivalence set: tmp%1#0, tmp%3#0, tmp%5#0, tmp%7#0, tmp%9#0, tmp%11#0, tmp%13#0, tmp%15#0 +debug: selected tmp%1#0 from equivalence set +debug: Copy propagation made 7 modifications +debug: Replacing redundant declaration let event%1#0: bytes = (concat method "ARC4TestStruct(uint64)" tmp%1#0) with copy of existing registers [Register(source_location=structure_methods/contract.py:59:8-49, ir_type=bytes, name='event%0', version=0)] +debug: Replacing redundant declaration let event%2#0: bytes = (concat method "ARC4TestStruct(uint64)" tmp%1#0) with copy of existing registers [Register(source_location=structure_methods/contract.py:59:8-49, ir_type=bytes, name='event%0', version=0)] +debug: Replacing redundant declaration let event%3#0: bytes = (concat method "ARC4TestStruct(uint64)" tmp%1#0) with copy of existing registers [Register(source_location=structure_methods/contract.py:59:8-49, ir_type=bytes, name='event%0', version=0)] +debug: Replacing redundant declaration let event%4#0: bytes = (concat method "ARC4TestStruct(uint64)" tmp%1#0) with copy of existing registers [Register(source_location=structure_methods/contract.py:59:8-49, ir_type=bytes, name='event%0', version=0)] +debug: Replacing redundant declaration let event%5#0: bytes = (concat method "ARC4TestStruct(uint64)" tmp%1#0) with copy of existing registers [Register(source_location=structure_methods/contract.py:59:8-49, ir_type=bytes, name='event%0', version=0)] +debug: Replacing redundant declaration let event%6#0: bytes = (concat method "ARC4TestStruct(uint64)" tmp%1#0) with copy of existing registers [Register(source_location=structure_methods/contract.py:59:8-49, ir_type=bytes, name='event%0', version=0)] +debug: Replacing redundant declaration let event%7#0: bytes = (concat method "ARC4TestStruct(uint64)" tmp%1#0) with copy of existing registers [Register(source_location=structure_methods/contract.py:59:8-49, ir_type=bytes, name='event%0', version=0)] +debug: Found equivalence set: event%0#0, event%1#0, event%2#0, event%3#0, event%4#0, event%5#0, event%6#0, event%7#0 +debug: selected event%0#0 from equivalence set +debug: Copy propagation made 7 modifications +debug: Optimizer: Encode Decode Pair Elimination +debug: Optimizer: Merge Chained Aggregate Reads +debug: Optimizer: Replace Aggregate Box Ops +debug: Optimizer: Minimize Box Exist Asserts +debug: Optimizer: Constant Reads And Unobserved Writes Elimination +debug: Optimizing subroutine test_cases.structure_methods.contract.TestContract.__puya_arc4_router__ +debug: Optimizer: Perform Subroutine Inlining +debug: inlining call to test_cases.structure_methods.contract.TestContract.__algopy_default_create in test_cases.structure_methods.contract.TestContract.__puya_arc4_router__ +debug: Optimizer: Split Parallel Copies +debug: Optimizer: Constant Replacer +debug: Optimizer: Copy Propagation +debug: Optimizer: Elide Itxn Field Calls +debug: Optimizer: Remove Unused Variables +debug: Optimizer: Intrinsic Simplifier +debug: Simplified (== tmp%3#0 NoOp) to (! tmp%3#0) +debug: Simplified (&& tmp%4#0 tmp%6#0) to (&& tmp%4#0 tmp%5#0) +debug: Simplified (== tmp%8#0 NoOp) to (! tmp%8#0) +debug: Simplified (== tmp%10#0 0u) to (! tmp%10#0) +debug: Optimizer: Inner Txn Field Replacer +debug: Optimizer: Replace Compiled References +debug: Optimizer: Simplify Control Ops +debug: simplifying exit 0 to err +debug: simplified terminator of block@5 from exit 0u to fail +debug: Optimizer: Merge Blocks +debug: Replaced predecessor block@6 with block@4 in block@7 +debug: Merged linear block@6 into block@4 +debug: Merged linear block@7 into block@4 +debug: Merged linear block@5 into block@3 +debug: Optimizer: Remove Linear Jumps +debug: Optimizer: Remove Unreachable Blocks +debug: Optimizer: Repeated Expression Elimination +debug: Optimizer: Encode Decode Pair Elimination +debug: Optimizer: Merge Chained Aggregate Reads +debug: Optimizer: Replace Aggregate Box Ops +debug: Optimizer: Minimize Box Exist Asserts +debug: Optimizer: Constant Reads And Unobserved Writes Elimination +debug: Optimizing subroutine test_cases.structure_methods.contract.TestContract.test[routing] +debug: Optimizer: Perform Subroutine Inlining +structure_methods/contract.py:70:6 debug: inlining call to test_cases.structure_methods.contract.TestContract.test in test_cases.structure_methods.contract.TestContract.test[routing] +debug: Optimizer: Split Parallel Copies +debug: Optimizer: Constant Replacer +debug: Optimizer: Copy Propagation +debug: Optimizer: Elide Itxn Field Calls +debug: Optimizer: Remove Unused Variables +debug: Optimizer: Intrinsic Simplifier +debug: Optimizer: Inner Txn Field Replacer +debug: Optimizer: Replace Compiled References +debug: Optimizer: Simplify Control Ops +debug: Optimizer: Merge Blocks +debug: Replaced predecessor block@1 with block@0 in block@2 +debug: Merged linear block@1 into block@0 +debug: Merged linear block@2 into block@0 +debug: Optimizer: Remove Linear Jumps +debug: Optimizer: Remove Unreachable Blocks +debug: Optimizer: Repeated Expression Elimination +debug: Replacing redundant declaration let tmp%6#0: Encoded(uint64) = bytes_encode<(uint64)>(0x0000000000000009) with copy of existing registers [Register(source_location=structure_methods/contract.py:73:29-59, ir_type=Encoded(uint64), name='tmp%0', version=0)] +debug: Replacing redundant declaration let tmp%8#0: Encoded(uint64) = bytes_encode<(uint64)>(9u) with copy of existing registers [Register(source_location=structure_methods/contract.py:74:29-50, ir_type=Encoded(uint64), name='tmp%2', version=0)] +debug: Found equivalence set: tmp%0#0, tmp%6#0 +debug: selected tmp%0#0 from equivalence set +debug: Found equivalence set: tmp%2#0, tmp%8#0 +debug: selected tmp%2#0 from equivalence set +debug: Copy propagation made 2 modifications +debug: Optimizer: Encode Decode Pair Elimination +debug: Optimizer: Merge Chained Aggregate Reads +debug: Optimizer: Replace Aggregate Box Ops +debug: Optimizer: Minimize Box Exist Asserts +debug: Optimizer: Constant Reads And Unobserved Writes Elimination +debug: Optimizing subroutine test_cases.structure_methods.contract.TestContract.test +debug: Optimizer: Perform Subroutine Inlining +structure_methods/contract.py:87:29 debug: inlining call to test_cases.structure_methods.contract.ARC4TestStruct.return1 in test_cases.structure_methods.contract.TestContract.test +structure_methods/contract.py:88:29 debug: inlining call to test_cases.structure_methods.contract.TestStruct.return1 in test_cases.structure_methods.contract.TestContract.test +structure_methods/contract.py:89:29 debug: inlining call to test_cases.structure_methods.contract.TestNamedTuple.return1 in test_cases.structure_methods.contract.TestContract.test +structure_methods/contract.py:92:29 debug: inlining call to test_cases.structure_methods.contract.ARC4TestStruct.return1 in test_cases.structure_methods.contract.TestContract.test +structure_methods/contract.py:93:29 debug: inlining call to test_cases.structure_methods.contract.TestStruct.return1 in test_cases.structure_methods.contract.TestContract.test +structure_methods/contract.py:94:29 debug: inlining call to test_cases.structure_methods.contract.TestNamedTuple.return1 in test_cases.structure_methods.contract.TestContract.test +structure_methods/contract.py:105:9 debug: inlining call to test_cases.structure_methods.contract.GroupedMethods.always_inlined_not_usually_inlined in test_cases.structure_methods.contract.TestContract.test +structure_methods/contract.py:106:9 debug: inlining call to test_cases.structure_methods.contract.GroupedMethods.always_inlined_not_usually_inlined in test_cases.structure_methods.contract.TestContract.test +debug: Optimizer: Split Parallel Copies +debug: Optimizer: Constant Replacer +debug: Optimizer: Copy Propagation +debug: Optimizer: Elide Itxn Field Calls +debug: Optimizer: Remove Unused Variables +debug: Removing unused variable tmp%12#0 +debug: Removing unused variable tmp%14#0 +debug: Removing unused variable tmp%16#0 +debug: Removing unused variable tmp%18#0 +debug: Removing unused variable tmp%20#0 +debug: Removing unused variable tmp%22#0 +debug: Removing unused variable v#0 +debug: Removing unused variable v#1 +debug: Optimizer: Intrinsic Simplifier +debug: Simplified (== 1u 1u) to 1u +debug: Simplified (== 1u 1u) to 1u +debug: Simplified (== 1u 1u) to 1u +debug: Simplified (== 1u 1u) to 1u +debug: Simplified (== 1u 1u) to 1u +debug: Simplified (== 1u 1u) to 1u +debug: Optimizer: Inner Txn Field Replacer +debug: Optimizer: Replace Compiled References +debug: Optimizer: Simplify Control Ops +debug: Optimizer: Merge Blocks +debug: Replaced predecessor block@1 with block@0 in block@2 +debug: Merged linear block@1 into block@0 +debug: Replaced predecessor block@2 with block@0 in block@3 +debug: Merged linear block@2 into block@0 +debug: Replaced predecessor block@3 with block@0 in block@4 +debug: Merged linear block@3 into block@0 +debug: Replaced predecessor block@4 with block@0 in block@5 +debug: Merged linear block@4 into block@0 +debug: Replaced predecessor block@5 with block@0 in block@6 +debug: Merged linear block@5 into block@0 +debug: Replaced predecessor block@6 with block@0 in block@7 +debug: Merged linear block@6 into block@0 +debug: Replaced predecessor block@7 with block@0 in block@8 +debug: Merged linear block@7 into block@0 +debug: Replaced predecessor block@8 with block@0 in block@9 +debug: Merged linear block@8 into block@0 +debug: Replaced predecessor block@9 with block@0 in block@10 +debug: Merged linear block@9 into block@0 +debug: Replaced predecessor block@10 with block@0 in block@11 +debug: Merged linear block@10 into block@0 +debug: Replaced predecessor block@11 with block@0 in block@12 +debug: Merged linear block@11 into block@0 +debug: Replaced predecessor block@12 with block@0 in block@13 +debug: Merged linear block@12 into block@0 +debug: Replaced predecessor block@13 with block@0 in block@14 +debug: Merged linear block@13 into block@0 +debug: Replaced predecessor block@14 with block@0 in block@15 +debug: Merged linear block@14 into block@0 +debug: Replaced predecessor block@15 with block@0 in block@16 +debug: Merged linear block@15 into block@0 +debug: Merged linear block@16 into block@0 +debug: Optimizer: Remove Linear Jumps +debug: Optimizer: Remove Unreachable Blocks +debug: Optimizer: Repeated Expression Elimination +debug: Replacing redundant declaration let tmp%6#0: Encoded(uint64) = bytes_encode<(uint64)>(0x0000000000000009) with copy of existing registers [Register(source_location=structure_methods/contract.py:73:29-59, ir_type=Encoded(uint64), name='tmp%0', version=0)] +debug: Replacing redundant declaration let tmp%8#0: Encoded(uint64) = bytes_encode<(uint64)>(9u) with copy of existing registers [Register(source_location=structure_methods/contract.py:74:29-50, ir_type=Encoded(uint64), name='tmp%2', version=0)] +debug: Replacing redundant declaration let tmp%0#2: Encoded(uint64) = bytes_encode(2u) with copy of existing registers [Register(source_location=structure_methods/contract.py:46:33-47, ir_type=Encoded(uint64), name='tmp%0', version=1)] +debug: Found equivalence set: tmp%0#0, tmp%6#0 +debug: selected tmp%0#0 from equivalence set +debug: Found equivalence set: tmp%2#0, tmp%8#0 +debug: selected tmp%2#0 from equivalence set +debug: Found equivalence set: tmp%0#1, tmp%0#2 +debug: selected tmp%0#1 from equivalence set +debug: Copy propagation made 3 modifications +debug: Replacing redundant declaration let tmp%1#2: Encoded(uint64) = bytes_encode<(uint64)>(tmp%0#1) with copy of existing registers [Register(source_location=structure_methods/contract.py:46:18-48, ir_type=Encoded(uint64), name='tmp%1', version=1)] +debug: Found equivalence set: tmp%1#1, tmp%1#2 +debug: selected tmp%1#1 from equivalence set +debug: Copy propagation made 1 modifications +debug: Replacing redundant declaration let event%0#1: bytes = (concat method "ARC4TestStruct(uint64)" tmp%1#1) with copy of existing registers [Register(source_location=structure_methods/contract.py:46:8-49, ir_type=bytes, name='event%0', version=0)] +debug: Found equivalence set: event%0#0, event%0#1 +debug: selected event%0#0 from equivalence set +debug: Copy propagation made 8 modifications +debug: Optimizer: Encode Decode Pair Elimination +debug: Optimizer: Merge Chained Aggregate Reads +debug: Optimizer: Replace Aggregate Box Ops +debug: Optimizer: Minimize Box Exist Asserts +debug: Optimizer: Constant Reads And Unobserved Writes Elimination +debug: Optimizing subroutine test_cases.structure_methods.contract.TestContract.__algopy_default_create +debug: Optimizer: Perform Subroutine Inlining +debug: Optimizer: Split Parallel Copies +debug: Optimizer: Constant Replacer +debug: Optimizer: Copy Propagation +debug: Optimizer: Elide Itxn Field Calls +debug: Optimizer: Remove Unused Variables +debug: Optimizer: Intrinsic Simplifier +debug: Optimizer: Inner Txn Field Replacer +debug: Optimizer: Replace Compiled References +debug: Optimizer: Simplify Control Ops +debug: Optimizer: Merge Blocks +debug: Optimizer: Remove Linear Jumps +debug: Optimizer: Remove Unreachable Blocks +debug: Optimizer: Repeated Expression Elimination +debug: Optimizer: Encode Decode Pair Elimination +debug: Optimizer: Merge Chained Aggregate Reads +debug: Optimizer: Replace Aggregate Box Ops +debug: Optimizer: Minimize Box Exist Asserts +debug: Optimizer: Constant Reads And Unobserved Writes Elimination +debug: removing unused subroutine test_cases.structure_methods.contract.TestContract.__puya_arc4_router__ +debug: removing unused subroutine test_cases.structure_methods.contract.TestContract.test +debug: Unused subroutines removed +debug: Output IR to structure_methods/out/TestContract.ir/TestContract.approval.001.ssa.opt.ir +debug: Begin optimization pass 2/100 +debug: marking trivial method test_cases.structure_methods.contract.ARC4TestStruct.return1 as inlineable +debug: marking trivial method test_cases.structure_methods.contract.TestStruct.return1 as inlineable +debug: marking trivial method test_cases.structure_methods.contract.TestNamedTuple.return1 as inlineable +debug: Optimizing subroutine algopy.arc4.ARC4Contract.approval_program +debug: Optimizer: Perform Subroutine Inlining +debug: inlining call to test_cases.structure_methods.contract.TestContract.__algopy_default_create in algopy.arc4.ARC4Contract.approval_program +debug: Optimizer: Split Parallel Copies +debug: Optimizer: Constant Replacer +debug: Optimizer: Copy Propagation +debug: Optimizer: Elide Itxn Field Calls +debug: Optimizer: Remove Unused Variables +debug: Removing unused variable tmp%1#0 +debug: Removing unused variable tmp%6#0 +debug: Optimizer: Intrinsic Simplifier +debug: Optimizer: Inner Txn Field Replacer +debug: Optimizer: Replace Compiled References +debug: Optimizer: Simplify Control Ops +debug: Optimizer: Merge Blocks +debug: Replaced predecessor block@6 with block@5 in block@7 +debug: Merged linear block@6 into block@5 +debug: Merged linear block@7 into block@5 +debug: Optimizer: Remove Linear Jumps +debug: Optimizer: Remove Unreachable Blocks +debug: Optimizer: Repeated Expression Elimination +debug: Optimizer: Encode Decode Pair Elimination +debug: Optimizer: Merge Chained Aggregate Reads +debug: Optimizer: Replace Aggregate Box Ops +debug: Optimizer: Minimize Box Exist Asserts +debug: Optimizer: Constant Reads And Unobserved Writes Elimination +debug: Optimizing subroutine test_cases.structure_methods.contract.ARC4TestStruct.return_value_times +debug: Optimizer: Perform Subroutine Inlining +debug: Optimizer: Split Parallel Copies +debug: Optimizer: Constant Replacer +debug: Optimizer: Copy Propagation +debug: Optimizer: Elide Itxn Field Calls +debug: Optimizer: Remove Unused Variables +debug: Optimizer: Intrinsic Simplifier +debug: Optimizer: Inner Txn Field Replacer +debug: Optimizer: Replace Compiled References +debug: Optimizer: Simplify Control Ops +debug: Optimizer: Merge Blocks +debug: Optimizer: Remove Linear Jumps +debug: Optimizer: Remove Unreachable Blocks +debug: Optimizer: Repeated Expression Elimination +debug: Optimizer: Encode Decode Pair Elimination +debug: Optimizer: Merge Chained Aggregate Reads +debug: Optimizer: Replace Aggregate Box Ops +debug: Optimizer: Minimize Box Exist Asserts +debug: Optimizer: Constant Reads And Unobserved Writes Elimination +debug: Optimizing subroutine test_cases.structure_methods.contract.ARC4TestStruct.return1 +debug: Optimizer: Perform Subroutine Inlining +debug: Optimizer: Split Parallel Copies +debug: Optimizer: Constant Replacer +debug: Optimizer: Copy Propagation +debug: Optimizer: Elide Itxn Field Calls +debug: Optimizer: Remove Unused Variables +debug: Optimizer: Intrinsic Simplifier +debug: Optimizer: Inner Txn Field Replacer +debug: Optimizer: Replace Compiled References +debug: Optimizer: Simplify Control Ops +debug: Optimizer: Merge Blocks +debug: Optimizer: Remove Linear Jumps +debug: Optimizer: Remove Unreachable Blocks +debug: Optimizer: Repeated Expression Elimination +debug: Optimizer: Encode Decode Pair Elimination +debug: Optimizer: Merge Chained Aggregate Reads +debug: Optimizer: Replace Aggregate Box Ops +debug: Optimizer: Minimize Box Exist Asserts +debug: Optimizer: Constant Reads And Unobserved Writes Elimination +debug: Optimizing subroutine test_cases.structure_methods.contract.TestStruct.return_value_times +debug: Optimizer: Perform Subroutine Inlining +debug: Optimizer: Split Parallel Copies +debug: Optimizer: Constant Replacer +debug: Optimizer: Copy Propagation +debug: Optimizer: Elide Itxn Field Calls +debug: Optimizer: Remove Unused Variables +debug: Optimizer: Intrinsic Simplifier +debug: Optimizer: Inner Txn Field Replacer +debug: Optimizer: Replace Compiled References +debug: Optimizer: Simplify Control Ops +debug: Optimizer: Merge Blocks +debug: Optimizer: Remove Linear Jumps +debug: Optimizer: Remove Unreachable Blocks +debug: Optimizer: Repeated Expression Elimination +debug: Optimizer: Encode Decode Pair Elimination +debug: Optimizer: Merge Chained Aggregate Reads +debug: Optimizer: Replace Aggregate Box Ops +debug: Optimizer: Minimize Box Exist Asserts +debug: Optimizer: Constant Reads And Unobserved Writes Elimination +debug: Optimizing subroutine test_cases.structure_methods.contract.TestStruct.return1 +debug: Optimizer: Perform Subroutine Inlining +debug: Optimizer: Split Parallel Copies +debug: Optimizer: Constant Replacer +debug: Optimizer: Copy Propagation +debug: Optimizer: Elide Itxn Field Calls +debug: Optimizer: Remove Unused Variables +debug: Optimizer: Intrinsic Simplifier +debug: Optimizer: Inner Txn Field Replacer +debug: Optimizer: Replace Compiled References +debug: Optimizer: Simplify Control Ops +debug: Optimizer: Merge Blocks +debug: Optimizer: Remove Linear Jumps +debug: Optimizer: Remove Unreachable Blocks +debug: Optimizer: Repeated Expression Elimination +debug: Optimizer: Encode Decode Pair Elimination +debug: Optimizer: Merge Chained Aggregate Reads +debug: Optimizer: Replace Aggregate Box Ops +debug: Optimizer: Minimize Box Exist Asserts +debug: Optimizer: Constant Reads And Unobserved Writes Elimination +debug: Optimizing subroutine test_cases.structure_methods.contract.TestNamedTuple.return_value_times +debug: Optimizer: Perform Subroutine Inlining +debug: Optimizer: Split Parallel Copies +debug: Optimizer: Constant Replacer +debug: Optimizer: Copy Propagation +debug: Optimizer: Elide Itxn Field Calls +debug: Optimizer: Remove Unused Variables +debug: Optimizer: Intrinsic Simplifier +debug: Optimizer: Inner Txn Field Replacer +debug: Optimizer: Replace Compiled References +debug: Optimizer: Simplify Control Ops +debug: Optimizer: Merge Blocks +debug: Optimizer: Remove Linear Jumps +debug: Optimizer: Remove Unreachable Blocks +debug: Optimizer: Repeated Expression Elimination +debug: Optimizer: Encode Decode Pair Elimination +debug: Optimizer: Merge Chained Aggregate Reads +debug: Optimizer: Replace Aggregate Box Ops +debug: Optimizer: Minimize Box Exist Asserts +debug: Optimizer: Constant Reads And Unobserved Writes Elimination +debug: Optimizing subroutine test_cases.structure_methods.contract.TestNamedTuple.return1 +debug: Optimizer: Perform Subroutine Inlining +debug: Optimizer: Split Parallel Copies +debug: Optimizer: Constant Replacer +debug: Optimizer: Copy Propagation +debug: Optimizer: Elide Itxn Field Calls +debug: Optimizer: Remove Unused Variables +debug: Optimizer: Intrinsic Simplifier +debug: Optimizer: Inner Txn Field Replacer +debug: Optimizer: Replace Compiled References +debug: Optimizer: Simplify Control Ops +debug: Optimizer: Merge Blocks +debug: Optimizer: Remove Linear Jumps +debug: Optimizer: Remove Unreachable Blocks +debug: Optimizer: Repeated Expression Elimination +debug: Optimizer: Encode Decode Pair Elimination +debug: Optimizer: Merge Chained Aggregate Reads +debug: Optimizer: Replace Aggregate Box Ops +debug: Optimizer: Minimize Box Exist Asserts +debug: Optimizer: Constant Reads And Unobserved Writes Elimination +debug: Optimizing subroutine test_cases.structure_methods.contract.GroupedMethods.never_inlined_usually_inlined +debug: Optimizer: Perform Subroutine Inlining +debug: Optimizer: Split Parallel Copies +debug: Optimizer: Constant Replacer +debug: Optimizer: Copy Propagation +debug: Optimizer: Elide Itxn Field Calls +debug: Optimizer: Remove Unused Variables +debug: Optimizer: Intrinsic Simplifier +debug: Optimizer: Inner Txn Field Replacer +debug: Optimizer: Replace Compiled References +debug: Optimizer: Simplify Control Ops +debug: Optimizer: Merge Blocks +debug: Optimizer: Remove Linear Jumps +debug: Optimizer: Remove Unreachable Blocks +debug: Optimizer: Repeated Expression Elimination +debug: Optimizer: Encode Decode Pair Elimination +debug: Optimizer: Merge Chained Aggregate Reads +debug: Optimizer: Replace Aggregate Box Ops +debug: Optimizer: Minimize Box Exist Asserts +debug: Optimizer: Constant Reads And Unobserved Writes Elimination +debug: Optimizing subroutine test_cases.structure_methods.contract.GroupedMethods.always_inlined_not_usually_inlined +debug: Optimizer: Perform Subroutine Inlining +debug: Optimizer: Split Parallel Copies +debug: Optimizer: Constant Replacer +debug: Optimizer: Copy Propagation +debug: Optimizer: Elide Itxn Field Calls +debug: Optimizer: Remove Unused Variables +debug: Optimizer: Intrinsic Simplifier +debug: Optimizer: Inner Txn Field Replacer +debug: Optimizer: Replace Compiled References +debug: Optimizer: Simplify Control Ops +debug: Optimizer: Merge Blocks +debug: Optimizer: Remove Linear Jumps +debug: Optimizer: Remove Unreachable Blocks +debug: Optimizer: Repeated Expression Elimination +debug: Optimizer: Encode Decode Pair Elimination +debug: Optimizer: Merge Chained Aggregate Reads +debug: Optimizer: Replace Aggregate Box Ops +debug: Optimizer: Minimize Box Exist Asserts +debug: Optimizer: Constant Reads And Unobserved Writes Elimination +debug: Optimizing subroutine test_cases.structure_methods.contract.GroupedMethods.usually_inlined +debug: Optimizer: Perform Subroutine Inlining +debug: Optimizer: Split Parallel Copies +debug: Optimizer: Constant Replacer +debug: Optimizer: Copy Propagation +debug: Optimizer: Elide Itxn Field Calls +debug: Optimizer: Remove Unused Variables +debug: Optimizer: Intrinsic Simplifier +debug: Optimizer: Inner Txn Field Replacer +debug: Optimizer: Replace Compiled References +debug: Optimizer: Simplify Control Ops +debug: Optimizer: Merge Blocks +debug: Optimizer: Remove Linear Jumps +debug: Optimizer: Remove Unreachable Blocks +debug: Optimizer: Repeated Expression Elimination +debug: Optimizer: Encode Decode Pair Elimination +debug: Optimizer: Merge Chained Aggregate Reads +debug: Optimizer: Replace Aggregate Box Ops +debug: Optimizer: Minimize Box Exist Asserts +debug: Optimizer: Constant Reads And Unobserved Writes Elimination +debug: Optimizing subroutine test_cases.structure_methods.contract.GroupedMethods.not_usually_inlined +debug: Optimizer: Perform Subroutine Inlining +debug: Optimizer: Split Parallel Copies +debug: Optimizer: Constant Replacer +debug: Optimizer: Copy Propagation +debug: Optimizer: Elide Itxn Field Calls +debug: Optimizer: Remove Unused Variables +debug: Optimizer: Intrinsic Simplifier +debug: Optimizer: Inner Txn Field Replacer +debug: Optimizer: Replace Compiled References +debug: Optimizer: Simplify Control Ops +debug: Optimizer: Merge Blocks +debug: Optimizer: Remove Linear Jumps +debug: Optimizer: Remove Unreachable Blocks +debug: Optimizer: Repeated Expression Elimination +debug: Optimizer: Encode Decode Pair Elimination +debug: Optimizer: Merge Chained Aggregate Reads +debug: Optimizer: Replace Aggregate Box Ops +debug: Optimizer: Minimize Box Exist Asserts +debug: Optimizer: Constant Reads And Unobserved Writes Elimination +debug: Optimizing subroutine test_cases.structure_methods.contract.TestContract.test[routing] +debug: Optimizer: Perform Subroutine Inlining +structure_methods/contract.py:87:29 debug: inlining call to test_cases.structure_methods.contract.ARC4TestStruct.return1 in test_cases.structure_methods.contract.TestContract.test[routing] +structure_methods/contract.py:88:29 debug: inlining call to test_cases.structure_methods.contract.TestStruct.return1 in test_cases.structure_methods.contract.TestContract.test[routing] +structure_methods/contract.py:89:29 debug: inlining call to test_cases.structure_methods.contract.TestNamedTuple.return1 in test_cases.structure_methods.contract.TestContract.test[routing] +structure_methods/contract.py:92:29 debug: inlining call to test_cases.structure_methods.contract.ARC4TestStruct.return1 in test_cases.structure_methods.contract.TestContract.test[routing] +structure_methods/contract.py:93:29 debug: inlining call to test_cases.structure_methods.contract.TestStruct.return1 in test_cases.structure_methods.contract.TestContract.test[routing] +structure_methods/contract.py:94:29 debug: inlining call to test_cases.structure_methods.contract.TestNamedTuple.return1 in test_cases.structure_methods.contract.TestContract.test[routing] +structure_methods/contract.py:105:9 debug: inlining call to test_cases.structure_methods.contract.GroupedMethods.always_inlined_not_usually_inlined in test_cases.structure_methods.contract.TestContract.test[routing] +structure_methods/contract.py:106:9 debug: inlining call to test_cases.structure_methods.contract.GroupedMethods.always_inlined_not_usually_inlined in test_cases.structure_methods.contract.TestContract.test[routing] +debug: Optimizer: Split Parallel Copies +debug: Optimizer: Constant Replacer +debug: Optimizer: Copy Propagation +debug: Optimizer: Elide Itxn Field Calls +debug: Optimizer: Remove Unused Variables +debug: Removing unused variable tmp%12#0 +debug: Removing unused variable tmp%14#0 +debug: Removing unused variable tmp%16#0 +debug: Removing unused variable tmp%18#0 +debug: Removing unused variable tmp%20#0 +debug: Removing unused variable tmp%22#0 +debug: Removing unused variable v#0 +debug: Removing unused variable v#1 +debug: Optimizer: Intrinsic Simplifier +debug: Simplified (== 1u 1u) to 1u +debug: Simplified (== 1u 1u) to 1u +debug: Simplified (== 1u 1u) to 1u +debug: Simplified (== 1u 1u) to 1u +debug: Simplified (== 1u 1u) to 1u +debug: Simplified (== 1u 1u) to 1u +debug: Optimizer: Inner Txn Field Replacer +debug: Optimizer: Replace Compiled References +debug: Optimizer: Simplify Control Ops +debug: Optimizer: Merge Blocks +debug: Replaced predecessor block@1 with block@0 in block@2 +debug: Merged linear block@1 into block@0 +debug: Replaced predecessor block@2 with block@0 in block@3 +debug: Merged linear block@2 into block@0 +debug: Replaced predecessor block@3 with block@0 in block@4 +debug: Merged linear block@3 into block@0 +debug: Replaced predecessor block@4 with block@0 in block@5 +debug: Merged linear block@4 into block@0 +debug: Replaced predecessor block@5 with block@0 in block@6 +debug: Merged linear block@5 into block@0 +debug: Replaced predecessor block@6 with block@0 in block@7 +debug: Merged linear block@6 into block@0 +debug: Replaced predecessor block@7 with block@0 in block@8 +debug: Merged linear block@7 into block@0 +debug: Replaced predecessor block@8 with block@0 in block@9 +debug: Merged linear block@8 into block@0 +debug: Replaced predecessor block@9 with block@0 in block@10 +debug: Merged linear block@9 into block@0 +debug: Replaced predecessor block@10 with block@0 in block@11 +debug: Merged linear block@10 into block@0 +debug: Replaced predecessor block@11 with block@0 in block@12 +debug: Merged linear block@11 into block@0 +debug: Replaced predecessor block@12 with block@0 in block@13 +debug: Merged linear block@12 into block@0 +debug: Replaced predecessor block@13 with block@0 in block@14 +debug: Merged linear block@13 into block@0 +debug: Replaced predecessor block@14 with block@0 in block@15 +debug: Merged linear block@14 into block@0 +debug: Replaced predecessor block@15 with block@0 in block@16 +debug: Merged linear block@15 into block@0 +debug: Merged linear block@16 into block@0 +debug: Optimizer: Remove Linear Jumps +debug: Optimizer: Remove Unreachable Blocks +debug: Optimizer: Repeated Expression Elimination +debug: Replacing redundant declaration let tmp%0#2: Encoded(uint64) = bytes_encode(2u) with copy of existing registers [Register(source_location=structure_methods/contract.py:46:33-47, ir_type=Encoded(uint64), name='tmp%0', version=1)] +debug: Found equivalence set: tmp%0#1, tmp%0#2 +debug: selected tmp%0#1 from equivalence set +debug: Copy propagation made 1 modifications +debug: Replacing redundant declaration let tmp%1#2: Encoded(uint64) = bytes_encode<(uint64)>(tmp%0#1) with copy of existing registers [Register(source_location=structure_methods/contract.py:46:18-48, ir_type=Encoded(uint64), name='tmp%1', version=1)] +debug: Found equivalence set: tmp%1#1, tmp%1#2 +debug: selected tmp%1#1 from equivalence set +debug: Copy propagation made 1 modifications +debug: Replacing redundant declaration let event%0#1: bytes = (concat method "ARC4TestStruct(uint64)" tmp%1#1) with copy of existing registers [Register(source_location=structure_methods/contract.py:46:8-49, ir_type=bytes, name='event%0', version=0)] +debug: Found equivalence set: event%0#0, event%0#1 +debug: selected event%0#0 from equivalence set +debug: Copy propagation made 8 modifications +debug: Optimizer: Encode Decode Pair Elimination +debug: Optimizer: Merge Chained Aggregate Reads +debug: Optimizer: Replace Aggregate Box Ops +debug: Optimizer: Minimize Box Exist Asserts +debug: Optimizer: Constant Reads And Unobserved Writes Elimination +debug: Optimizing subroutine test_cases.structure_methods.contract.TestContract.__algopy_default_create +debug: Optimizer: Perform Subroutine Inlining +debug: Optimizer: Split Parallel Copies +debug: Optimizer: Constant Replacer +debug: Optimizer: Copy Propagation +debug: Optimizer: Elide Itxn Field Calls +debug: Optimizer: Remove Unused Variables +debug: Optimizer: Intrinsic Simplifier +debug: Optimizer: Inner Txn Field Replacer +debug: Optimizer: Replace Compiled References +debug: Optimizer: Simplify Control Ops +debug: Optimizer: Merge Blocks +debug: Optimizer: Remove Linear Jumps +debug: Optimizer: Remove Unreachable Blocks +debug: Optimizer: Repeated Expression Elimination +debug: Optimizer: Encode Decode Pair Elimination +debug: Optimizer: Merge Chained Aggregate Reads +debug: Optimizer: Replace Aggregate Box Ops +debug: Optimizer: Minimize Box Exist Asserts +debug: Optimizer: Constant Reads And Unobserved Writes Elimination +debug: removing unused subroutine test_cases.structure_methods.contract.ARC4TestStruct.return1 +debug: removing unused subroutine test_cases.structure_methods.contract.TestStruct.return1 +debug: removing unused subroutine test_cases.structure_methods.contract.TestNamedTuple.return1 +debug: removing unused subroutine test_cases.structure_methods.contract.GroupedMethods.always_inlined_not_usually_inlined +debug: removing unused subroutine test_cases.structure_methods.contract.TestContract.__algopy_default_create +debug: Unused subroutines removed +debug: Output IR to structure_methods/out/TestContract.ir/TestContract.approval.002.ssa.opt.ir +debug: Begin optimization pass 3/100 +debug: marking simple function test_cases.structure_methods.contract.TestNamedTuple.return_value_times for inlining (complexity=1 <= threshold=4) +debug: marking simple function test_cases.structure_methods.contract.GroupedMethods.usually_inlined for inlining (complexity=1 <= threshold=3) +debug: Optimizing subroutine algopy.arc4.ARC4Contract.approval_program +debug: Optimizer: Perform Subroutine Inlining +debug: Optimizer: Split Parallel Copies +debug: Optimizer: Constant Replacer +debug: Optimizer: Copy Propagation +debug: Optimizer: Elide Itxn Field Calls +debug: Optimizer: Remove Unused Variables +debug: Optimizer: Intrinsic Simplifier +debug: Optimizer: Inner Txn Field Replacer +debug: Optimizer: Replace Compiled References +debug: Optimizer: Simplify Control Ops +debug: Optimizer: Merge Blocks +debug: Optimizer: Remove Linear Jumps +debug: Optimizer: Remove Unreachable Blocks +debug: Optimizer: Repeated Expression Elimination +debug: Optimizer: Encode Decode Pair Elimination +debug: Optimizer: Merge Chained Aggregate Reads +debug: Optimizer: Replace Aggregate Box Ops +debug: Optimizer: Minimize Box Exist Asserts +debug: Optimizer: Constant Reads And Unobserved Writes Elimination +debug: Optimizing subroutine test_cases.structure_methods.contract.ARC4TestStruct.return_value_times +debug: Optimizer: Perform Subroutine Inlining +debug: Optimizer: Split Parallel Copies +debug: Optimizer: Constant Replacer +debug: Optimizer: Copy Propagation +debug: Optimizer: Elide Itxn Field Calls +debug: Optimizer: Remove Unused Variables +debug: Optimizer: Intrinsic Simplifier +debug: Optimizer: Inner Txn Field Replacer +debug: Optimizer: Replace Compiled References +debug: Optimizer: Simplify Control Ops +debug: Optimizer: Merge Blocks +debug: Optimizer: Remove Linear Jumps +debug: Optimizer: Remove Unreachable Blocks +debug: Optimizer: Repeated Expression Elimination +debug: Optimizer: Encode Decode Pair Elimination +debug: Optimizer: Merge Chained Aggregate Reads +debug: Optimizer: Replace Aggregate Box Ops +debug: Optimizer: Minimize Box Exist Asserts +debug: Optimizer: Constant Reads And Unobserved Writes Elimination +debug: Optimizing subroutine test_cases.structure_methods.contract.TestStruct.return_value_times +debug: Optimizer: Perform Subroutine Inlining +debug: Optimizer: Split Parallel Copies +debug: Optimizer: Constant Replacer +debug: Optimizer: Copy Propagation +debug: Optimizer: Elide Itxn Field Calls +debug: Optimizer: Remove Unused Variables +debug: Optimizer: Intrinsic Simplifier +debug: Optimizer: Inner Txn Field Replacer +debug: Optimizer: Replace Compiled References +debug: Optimizer: Simplify Control Ops +debug: Optimizer: Merge Blocks +debug: Optimizer: Remove Linear Jumps +debug: Optimizer: Remove Unreachable Blocks +debug: Optimizer: Repeated Expression Elimination +debug: Optimizer: Encode Decode Pair Elimination +debug: Optimizer: Merge Chained Aggregate Reads +debug: Optimizer: Replace Aggregate Box Ops +debug: Optimizer: Minimize Box Exist Asserts +debug: Optimizer: Constant Reads And Unobserved Writes Elimination +debug: Optimizing subroutine test_cases.structure_methods.contract.TestNamedTuple.return_value_times +debug: Optimizer: Perform Subroutine Inlining +debug: Optimizer: Split Parallel Copies +debug: Optimizer: Constant Replacer +debug: Optimizer: Copy Propagation +debug: Optimizer: Elide Itxn Field Calls +debug: Optimizer: Remove Unused Variables +debug: Optimizer: Intrinsic Simplifier +debug: Optimizer: Inner Txn Field Replacer +debug: Optimizer: Replace Compiled References +debug: Optimizer: Simplify Control Ops +debug: Optimizer: Merge Blocks +debug: Optimizer: Remove Linear Jumps +debug: Optimizer: Remove Unreachable Blocks +debug: Optimizer: Repeated Expression Elimination +debug: Optimizer: Encode Decode Pair Elimination +debug: Optimizer: Merge Chained Aggregate Reads +debug: Optimizer: Replace Aggregate Box Ops +debug: Optimizer: Minimize Box Exist Asserts +debug: Optimizer: Constant Reads And Unobserved Writes Elimination +debug: Optimizing subroutine test_cases.structure_methods.contract.GroupedMethods.never_inlined_usually_inlined +debug: Optimizer: Perform Subroutine Inlining +debug: Optimizer: Split Parallel Copies +debug: Optimizer: Constant Replacer +debug: Optimizer: Copy Propagation +debug: Optimizer: Elide Itxn Field Calls +debug: Optimizer: Remove Unused Variables +debug: Optimizer: Intrinsic Simplifier +debug: Optimizer: Inner Txn Field Replacer +debug: Optimizer: Replace Compiled References +debug: Optimizer: Simplify Control Ops +debug: Optimizer: Merge Blocks +debug: Optimizer: Remove Linear Jumps +debug: Optimizer: Remove Unreachable Blocks +debug: Optimizer: Repeated Expression Elimination +debug: Optimizer: Encode Decode Pair Elimination +debug: Optimizer: Merge Chained Aggregate Reads +debug: Optimizer: Replace Aggregate Box Ops +debug: Optimizer: Minimize Box Exist Asserts +debug: Optimizer: Constant Reads And Unobserved Writes Elimination +debug: Optimizing subroutine test_cases.structure_methods.contract.GroupedMethods.usually_inlined +debug: Optimizer: Perform Subroutine Inlining +debug: Optimizer: Split Parallel Copies +debug: Optimizer: Constant Replacer +debug: Optimizer: Copy Propagation +debug: Optimizer: Elide Itxn Field Calls +debug: Optimizer: Remove Unused Variables +debug: Optimizer: Intrinsic Simplifier +debug: Optimizer: Inner Txn Field Replacer +debug: Optimizer: Replace Compiled References +debug: Optimizer: Simplify Control Ops +debug: Optimizer: Merge Blocks +debug: Optimizer: Remove Linear Jumps +debug: Optimizer: Remove Unreachable Blocks +debug: Optimizer: Repeated Expression Elimination +debug: Optimizer: Encode Decode Pair Elimination +debug: Optimizer: Merge Chained Aggregate Reads +debug: Optimizer: Replace Aggregate Box Ops +debug: Optimizer: Minimize Box Exist Asserts +debug: Optimizer: Constant Reads And Unobserved Writes Elimination +debug: Optimizing subroutine test_cases.structure_methods.contract.GroupedMethods.not_usually_inlined +debug: Optimizer: Perform Subroutine Inlining +debug: Optimizer: Split Parallel Copies +debug: Optimizer: Constant Replacer +debug: Optimizer: Copy Propagation +debug: Optimizer: Elide Itxn Field Calls +debug: Optimizer: Remove Unused Variables +debug: Optimizer: Intrinsic Simplifier +debug: Optimizer: Inner Txn Field Replacer +debug: Optimizer: Replace Compiled References +debug: Optimizer: Simplify Control Ops +debug: Optimizer: Merge Blocks +debug: Optimizer: Remove Linear Jumps +debug: Optimizer: Remove Unreachable Blocks +debug: Optimizer: Repeated Expression Elimination +debug: Optimizer: Encode Decode Pair Elimination +debug: Optimizer: Merge Chained Aggregate Reads +debug: Optimizer: Replace Aggregate Box Ops +debug: Optimizer: Minimize Box Exist Asserts +debug: Optimizer: Constant Reads And Unobserved Writes Elimination +debug: Optimizing subroutine test_cases.structure_methods.contract.TestContract.test[routing] +debug: Optimizer: Perform Subroutine Inlining +structure_methods/contract.py:75:30 debug: inlining call to test_cases.structure_methods.contract.TestNamedTuple.return_value_times in test_cases.structure_methods.contract.TestContract.test[routing] +structure_methods/contract.py:82:30 debug: inlining call to test_cases.structure_methods.contract.TestNamedTuple.return_value_times in test_cases.structure_methods.contract.TestContract.test[routing] +structure_methods/contract.py:103:29 debug: inlining call to test_cases.structure_methods.contract.GroupedMethods.usually_inlined in test_cases.structure_methods.contract.TestContract.test[routing] +structure_methods/contract.py:104:29 debug: inlining call to test_cases.structure_methods.contract.GroupedMethods.usually_inlined in test_cases.structure_methods.contract.TestContract.test[routing] +debug: Optimizer: Split Parallel Copies +debug: Optimizer: Constant Replacer +debug: Optimizer: Copy Propagation +debug: Found equivalence set: tmp%0#2, tmp%4#0 +debug: selected tmp%0#2 from equivalence set +debug: Found equivalence set: tmp%0#3, tmp%10#0 +debug: selected tmp%0#3 from equivalence set +debug: Found equivalence set: tmp%0#4, tmp%28#0 +debug: selected tmp%0#4 from equivalence set +debug: Found equivalence set: tmp%0#5, tmp%30#0 +debug: selected tmp%0#5 from equivalence set +debug: Copy propagation made 4 modifications +debug: Optimizer: Elide Itxn Field Calls +debug: Optimizer: Remove Unused Variables +debug: Removing unused variable self.value#0 +debug: Removing unused variable times#0 +debug: Removing unused variable self.value#1 +debug: Removing unused variable times#1 +debug: Removing unused variable tmp%13#0 +debug: Removing unused variable tmp%15#0 +debug: Removing unused variable tmp%17#0 +debug: Removing unused variable tmp%19#0 +debug: Removing unused variable tmp%21#0 +debug: Removing unused variable tmp%23#0 +debug: Removing unused variable v#0 +debug: Removing unused variable v#1 +debug: Optimizer: Intrinsic Simplifier +debug: Simplified (* 9u 2u) to 18u +debug: Simplified (== 18u 18u) to 1u +debug: Simplified (* 9u 2u) to 18u +debug: Simplified (== 18u 18u) to 1u +debug: Simplified (+ 2u 1u) to 3u +debug: Simplified (== 3u 3u) to 1u +debug: Simplified (+ 2u 1u) to 3u +debug: Simplified (== 3u 3u) to 1u +debug: Optimizer: Inner Txn Field Replacer +debug: Optimizer: Replace Compiled References +debug: Optimizer: Simplify Control Ops +debug: Optimizer: Merge Blocks +debug: Replaced predecessor block@1 with block@0 in block@2 +debug: Merged linear block@1 into block@0 +debug: Replaced predecessor block@2 with block@0 in block@3 +debug: Merged linear block@2 into block@0 +debug: Replaced predecessor block@3 with block@0 in block@4 +debug: Merged linear block@3 into block@0 +debug: Replaced predecessor block@4 with block@0 in block@5 +debug: Merged linear block@4 into block@0 +debug: Replaced predecessor block@5 with block@0 in block@6 +debug: Merged linear block@5 into block@0 +debug: Replaced predecessor block@6 with block@0 in block@7 +debug: Merged linear block@6 into block@0 +debug: Replaced predecessor block@7 with block@0 in block@8 +debug: Merged linear block@7 into block@0 +debug: Merged linear block@8 into block@0 +debug: Optimizer: Remove Linear Jumps +debug: Optimizer: Remove Unreachable Blocks +debug: Optimizer: Repeated Expression Elimination +debug: Optimizer: Encode Decode Pair Elimination +debug: Optimizer: Merge Chained Aggregate Reads +debug: Optimizer: Replace Aggregate Box Ops +debug: Optimizer: Minimize Box Exist Asserts +debug: Optimizer: Constant Reads And Unobserved Writes Elimination +debug: removing unused subroutine test_cases.structure_methods.contract.TestNamedTuple.return_value_times +debug: removing unused subroutine test_cases.structure_methods.contract.GroupedMethods.usually_inlined +debug: Unused subroutines removed +debug: Output IR to structure_methods/out/TestContract.ir/TestContract.approval.003.ssa.opt.ir +debug: Begin optimization pass 4/100 +debug: Optimizing subroutine algopy.arc4.ARC4Contract.approval_program +debug: Optimizer: Perform Subroutine Inlining +debug: Optimizer: Split Parallel Copies +debug: Optimizer: Constant Replacer +debug: Optimizer: Copy Propagation +debug: Optimizer: Elide Itxn Field Calls +debug: Optimizer: Remove Unused Variables +debug: Optimizer: Intrinsic Simplifier +debug: Optimizer: Inner Txn Field Replacer +debug: Optimizer: Replace Compiled References +debug: Optimizer: Simplify Control Ops +debug: Optimizer: Merge Blocks +debug: Optimizer: Remove Linear Jumps +debug: Optimizer: Remove Unreachable Blocks +debug: Optimizer: Repeated Expression Elimination +debug: Optimizer: Encode Decode Pair Elimination +debug: Optimizer: Merge Chained Aggregate Reads +debug: Optimizer: Replace Aggregate Box Ops +debug: Optimizer: Minimize Box Exist Asserts +debug: Optimizer: Constant Reads And Unobserved Writes Elimination +debug: Optimizing subroutine test_cases.structure_methods.contract.ARC4TestStruct.return_value_times +debug: Optimizer: Perform Subroutine Inlining +debug: Optimizer: Split Parallel Copies +debug: Optimizer: Constant Replacer +debug: Optimizer: Copy Propagation +debug: Optimizer: Elide Itxn Field Calls +debug: Optimizer: Remove Unused Variables +debug: Optimizer: Intrinsic Simplifier +debug: Optimizer: Inner Txn Field Replacer +debug: Optimizer: Replace Compiled References +debug: Optimizer: Simplify Control Ops +debug: Optimizer: Merge Blocks +debug: Optimizer: Remove Linear Jumps +debug: Optimizer: Remove Unreachable Blocks +debug: Optimizer: Repeated Expression Elimination +debug: Optimizer: Encode Decode Pair Elimination +debug: Optimizer: Merge Chained Aggregate Reads +debug: Optimizer: Replace Aggregate Box Ops +debug: Optimizer: Minimize Box Exist Asserts +debug: Optimizer: Constant Reads And Unobserved Writes Elimination +debug: Optimizing subroutine test_cases.structure_methods.contract.TestStruct.return_value_times +debug: Optimizer: Perform Subroutine Inlining +debug: Optimizer: Split Parallel Copies +debug: Optimizer: Constant Replacer +debug: Optimizer: Copy Propagation +debug: Optimizer: Elide Itxn Field Calls +debug: Optimizer: Remove Unused Variables +debug: Optimizer: Intrinsic Simplifier +debug: Optimizer: Inner Txn Field Replacer +debug: Optimizer: Replace Compiled References +debug: Optimizer: Simplify Control Ops +debug: Optimizer: Merge Blocks +debug: Optimizer: Remove Linear Jumps +debug: Optimizer: Remove Unreachable Blocks +debug: Optimizer: Repeated Expression Elimination +debug: Optimizer: Encode Decode Pair Elimination +debug: Optimizer: Merge Chained Aggregate Reads +debug: Optimizer: Replace Aggregate Box Ops +debug: Optimizer: Minimize Box Exist Asserts +debug: Optimizer: Constant Reads And Unobserved Writes Elimination +debug: Optimizing subroutine test_cases.structure_methods.contract.GroupedMethods.never_inlined_usually_inlined +debug: Optimizer: Perform Subroutine Inlining +debug: Optimizer: Split Parallel Copies +debug: Optimizer: Constant Replacer +debug: Optimizer: Copy Propagation +debug: Optimizer: Elide Itxn Field Calls +debug: Optimizer: Remove Unused Variables +debug: Optimizer: Intrinsic Simplifier +debug: Optimizer: Inner Txn Field Replacer +debug: Optimizer: Replace Compiled References +debug: Optimizer: Simplify Control Ops +debug: Optimizer: Merge Blocks +debug: Optimizer: Remove Linear Jumps +debug: Optimizer: Remove Unreachable Blocks +debug: Optimizer: Repeated Expression Elimination +debug: Optimizer: Encode Decode Pair Elimination +debug: Optimizer: Merge Chained Aggregate Reads +debug: Optimizer: Replace Aggregate Box Ops +debug: Optimizer: Minimize Box Exist Asserts +debug: Optimizer: Constant Reads And Unobserved Writes Elimination +debug: Optimizing subroutine test_cases.structure_methods.contract.GroupedMethods.not_usually_inlined +debug: Optimizer: Perform Subroutine Inlining +debug: Optimizer: Split Parallel Copies +debug: Optimizer: Constant Replacer +debug: Optimizer: Copy Propagation +debug: Optimizer: Elide Itxn Field Calls +debug: Optimizer: Remove Unused Variables +debug: Optimizer: Intrinsic Simplifier +debug: Optimizer: Inner Txn Field Replacer +debug: Optimizer: Replace Compiled References +debug: Optimizer: Simplify Control Ops +debug: Optimizer: Merge Blocks +debug: Optimizer: Remove Linear Jumps +debug: Optimizer: Remove Unreachable Blocks +debug: Optimizer: Repeated Expression Elimination +debug: Optimizer: Encode Decode Pair Elimination +debug: Optimizer: Merge Chained Aggregate Reads +debug: Optimizer: Replace Aggregate Box Ops +debug: Optimizer: Minimize Box Exist Asserts +debug: Optimizer: Constant Reads And Unobserved Writes Elimination +debug: Optimizing subroutine test_cases.structure_methods.contract.TestContract.test[routing] +debug: Optimizer: Perform Subroutine Inlining +debug: Optimizer: Split Parallel Copies +debug: Optimizer: Constant Replacer +debug: Optimizer: Copy Propagation +debug: Optimizer: Elide Itxn Field Calls +debug: Optimizer: Remove Unused Variables +debug: Removing unused variable tmp%0#2 +debug: Removing unused variable tmp%5#0 +debug: Removing unused variable tmp%0#3 +debug: Removing unused variable tmp%11#0 +debug: Removing unused variable tmp%0#4 +debug: Removing unused variable tmp%29#0 +debug: Removing unused variable tmp%0#5 +debug: Removing unused variable tmp%31#0 +debug: Optimizer: Intrinsic Simplifier +debug: Optimizer: Inner Txn Field Replacer +debug: Optimizer: Replace Compiled References +debug: Optimizer: Simplify Control Ops +debug: Optimizer: Merge Blocks +debug: Optimizer: Remove Linear Jumps +debug: Optimizer: Remove Unreachable Blocks +debug: Optimizer: Repeated Expression Elimination +debug: Optimizer: Encode Decode Pair Elimination +debug: Optimizer: Merge Chained Aggregate Reads +debug: Optimizer: Replace Aggregate Box Ops +debug: Optimizer: Minimize Box Exist Asserts +debug: Optimizer: Constant Reads And Unobserved Writes Elimination +debug: Output IR to structure_methods/out/TestContract.ir/TestContract.approval.004.ssa.opt.ir +debug: Begin optimization pass 5/100 +debug: Optimizing subroutine algopy.arc4.ARC4Contract.approval_program +debug: Optimizer: Perform Subroutine Inlining +debug: Optimizer: Split Parallel Copies +debug: Optimizer: Constant Replacer +debug: Optimizer: Copy Propagation +debug: Optimizer: Elide Itxn Field Calls +debug: Optimizer: Remove Unused Variables +debug: Optimizer: Intrinsic Simplifier +debug: Optimizer: Inner Txn Field Replacer +debug: Optimizer: Replace Compiled References +debug: Optimizer: Simplify Control Ops +debug: Optimizer: Merge Blocks +debug: Optimizer: Remove Linear Jumps +debug: Optimizer: Remove Unreachable Blocks +debug: Optimizer: Repeated Expression Elimination +debug: Optimizer: Encode Decode Pair Elimination +debug: Optimizer: Merge Chained Aggregate Reads +debug: Optimizer: Replace Aggregate Box Ops +debug: Optimizer: Minimize Box Exist Asserts +debug: Optimizer: Constant Reads And Unobserved Writes Elimination +debug: Optimizing subroutine test_cases.structure_methods.contract.ARC4TestStruct.return_value_times +debug: Optimizer: Perform Subroutine Inlining +debug: Optimizer: Split Parallel Copies +debug: Optimizer: Constant Replacer +debug: Optimizer: Copy Propagation +debug: Optimizer: Elide Itxn Field Calls +debug: Optimizer: Remove Unused Variables +debug: Optimizer: Intrinsic Simplifier +debug: Optimizer: Inner Txn Field Replacer +debug: Optimizer: Replace Compiled References +debug: Optimizer: Simplify Control Ops +debug: Optimizer: Merge Blocks +debug: Optimizer: Remove Linear Jumps +debug: Optimizer: Remove Unreachable Blocks +debug: Optimizer: Repeated Expression Elimination +debug: Optimizer: Encode Decode Pair Elimination +debug: Optimizer: Merge Chained Aggregate Reads +debug: Optimizer: Replace Aggregate Box Ops +debug: Optimizer: Minimize Box Exist Asserts +debug: Optimizer: Constant Reads And Unobserved Writes Elimination +debug: Optimizing subroutine test_cases.structure_methods.contract.TestStruct.return_value_times +debug: Optimizer: Perform Subroutine Inlining +debug: Optimizer: Split Parallel Copies +debug: Optimizer: Constant Replacer +debug: Optimizer: Copy Propagation +debug: Optimizer: Elide Itxn Field Calls +debug: Optimizer: Remove Unused Variables +debug: Optimizer: Intrinsic Simplifier +debug: Optimizer: Inner Txn Field Replacer +debug: Optimizer: Replace Compiled References +debug: Optimizer: Simplify Control Ops +debug: Optimizer: Merge Blocks +debug: Optimizer: Remove Linear Jumps +debug: Optimizer: Remove Unreachable Blocks +debug: Optimizer: Repeated Expression Elimination +debug: Optimizer: Encode Decode Pair Elimination +debug: Optimizer: Merge Chained Aggregate Reads +debug: Optimizer: Replace Aggregate Box Ops +debug: Optimizer: Minimize Box Exist Asserts +debug: Optimizer: Constant Reads And Unobserved Writes Elimination +debug: Optimizing subroutine test_cases.structure_methods.contract.GroupedMethods.never_inlined_usually_inlined +debug: Optimizer: Perform Subroutine Inlining +debug: Optimizer: Split Parallel Copies +debug: Optimizer: Constant Replacer +debug: Optimizer: Copy Propagation +debug: Optimizer: Elide Itxn Field Calls +debug: Optimizer: Remove Unused Variables +debug: Optimizer: Intrinsic Simplifier +debug: Optimizer: Inner Txn Field Replacer +debug: Optimizer: Replace Compiled References +debug: Optimizer: Simplify Control Ops +debug: Optimizer: Merge Blocks +debug: Optimizer: Remove Linear Jumps +debug: Optimizer: Remove Unreachable Blocks +debug: Optimizer: Repeated Expression Elimination +debug: Optimizer: Encode Decode Pair Elimination +debug: Optimizer: Merge Chained Aggregate Reads +debug: Optimizer: Replace Aggregate Box Ops +debug: Optimizer: Minimize Box Exist Asserts +debug: Optimizer: Constant Reads And Unobserved Writes Elimination +debug: Optimizing subroutine test_cases.structure_methods.contract.GroupedMethods.not_usually_inlined +debug: Optimizer: Perform Subroutine Inlining +debug: Optimizer: Split Parallel Copies +debug: Optimizer: Constant Replacer +debug: Optimizer: Copy Propagation +debug: Optimizer: Elide Itxn Field Calls +debug: Optimizer: Remove Unused Variables +debug: Optimizer: Intrinsic Simplifier +debug: Optimizer: Inner Txn Field Replacer +debug: Optimizer: Replace Compiled References +debug: Optimizer: Simplify Control Ops +debug: Optimizer: Merge Blocks +debug: Optimizer: Remove Linear Jumps +debug: Optimizer: Remove Unreachable Blocks +debug: Optimizer: Repeated Expression Elimination +debug: Optimizer: Encode Decode Pair Elimination +debug: Optimizer: Merge Chained Aggregate Reads +debug: Optimizer: Replace Aggregate Box Ops +debug: Optimizer: Minimize Box Exist Asserts +debug: Optimizer: Constant Reads And Unobserved Writes Elimination +debug: Optimizing subroutine test_cases.structure_methods.contract.TestContract.test[routing] +debug: Optimizer: Perform Subroutine Inlining +debug: Optimizer: Split Parallel Copies +debug: Optimizer: Constant Replacer +debug: Optimizer: Copy Propagation +debug: Optimizer: Elide Itxn Field Calls +debug: Optimizer: Remove Unused Variables +debug: Optimizer: Intrinsic Simplifier +debug: Optimizer: Inner Txn Field Replacer +debug: Optimizer: Replace Compiled References +debug: Optimizer: Simplify Control Ops +debug: Optimizer: Merge Blocks +debug: Optimizer: Remove Linear Jumps +debug: Optimizer: Remove Unreachable Blocks +debug: Optimizer: Repeated Expression Elimination +debug: Optimizer: Encode Decode Pair Elimination +debug: Optimizer: Merge Chained Aggregate Reads +debug: Optimizer: Replace Aggregate Box Ops +debug: Optimizer: Minimize Box Exist Asserts +debug: Optimizer: Constant Reads And Unobserved Writes Elimination +debug: No optimizations performed in pass 5, ending loop +debug: optimizing clear program of test_cases.structure_methods.contract.TestContract at level 1 +debug: Begin optimization pass 1/100 +debug: Optimizing subroutine algopy.arc4.ARC4Contract.clear_state_program +debug: Optimizer: Perform Subroutine Inlining +debug: Optimizer: Split Parallel Copies +debug: Optimizer: Constant Replacer +debug: Optimizer: Copy Propagation +debug: Optimizer: Elide Itxn Field Calls +debug: Optimizer: Remove Unused Variables +debug: Optimizer: Intrinsic Simplifier +debug: Optimizer: Inner Txn Field Replacer +debug: Optimizer: Replace Compiled References +debug: Optimizer: Simplify Control Ops +debug: Optimizer: Merge Blocks +debug: Optimizer: Remove Linear Jumps +debug: Optimizer: Remove Unreachable Blocks +debug: Optimizer: Repeated Expression Elimination +debug: Optimizer: Encode Decode Pair Elimination +debug: Optimizer: Merge Chained Aggregate Reads +debug: Optimizer: Replace Aggregate Box Ops +debug: Optimizer: Minimize Box Exist Asserts +debug: Optimizer: Constant Reads And Unobserved Writes Elimination +debug: No optimizations performed in pass 1, ending loop +debug: lowering array IR nodes in approval program of test_cases.structure_methods.contract.TestContract +debug: Output IR to structure_methods/out/TestContract.ir/TestContract.approval.100.ssa.array.ir +debug: lowering array IR nodes in clear program of test_cases.structure_methods.contract.TestContract +debug: Output IR to structure_methods/out/TestContract.ir/TestContract.clear.100.ssa.array.ir +debug: optimizing approval program of test_cases.structure_methods.contract.TestContract at level 1 +debug: Begin optimization pass 1/100 +debug: marking simple function test_cases.structure_methods.contract.ARC4TestStruct.return_value_times for inlining (complexity=4 <= threshold=4) +debug: marking simple function test_cases.structure_methods.contract.TestStruct.return_value_times for inlining (complexity=4 <= threshold=4) +debug: Optimizing subroutine algopy.arc4.ARC4Contract.approval_program +debug: Optimizer: Perform Subroutine Inlining +debug: Optimizer: Split Parallel Copies +debug: Optimizer: Constant Replacer +debug: Optimizer: Copy Propagation +debug: Optimizer: Elide Itxn Field Calls +debug: Optimizer: Remove Unused Variables +debug: Optimizer: Intrinsic Simplifier +debug: Optimizer: Inner Txn Field Replacer +debug: Optimizer: Replace Compiled References +debug: Optimizer: Simplify Control Ops +debug: Optimizer: Merge Blocks +debug: Optimizer: Remove Linear Jumps +debug: Optimizer: Remove Unreachable Blocks +debug: Optimizer: Repeated Expression Elimination +debug: Optimizer: Encode Decode Pair Elimination +debug: Optimizer: Merge Chained Aggregate Reads +debug: Optimizer: Replace Aggregate Box Ops +debug: Optimizer: Minimize Box Exist Asserts +debug: Optimizer: Constant Reads And Unobserved Writes Elimination +debug: Optimizing subroutine test_cases.structure_methods.contract.ARC4TestStruct.return_value_times +debug: Optimizer: Perform Subroutine Inlining +debug: Optimizer: Split Parallel Copies +debug: Optimizer: Constant Replacer +debug: Optimizer: Copy Propagation +debug: Found equivalence set: aggregate%extract%0#0, tuple_item%0#0 +debug: selected aggregate%extract%0#0 from equivalence set +debug: Copy propagation made 1 modifications +debug: Optimizer: Elide Itxn Field Calls +debug: Optimizer: Remove Unused Variables +debug: Optimizer: Intrinsic Simplifier +debug: Simplified (btoi aggregate%extract%0#0) to (extract_uint64 self#0 0u) +debug: Simplified (extract3 self#0 0u 8u) to ((extract 0 8) self#0) +debug: Optimizer: Inner Txn Field Replacer +debug: Optimizer: Replace Compiled References +debug: Optimizer: Simplify Control Ops +debug: Optimizer: Merge Blocks +debug: Optimizer: Remove Linear Jumps +debug: Optimizer: Remove Unreachable Blocks +debug: Optimizer: Repeated Expression Elimination +debug: Optimizer: Encode Decode Pair Elimination +debug: Optimizer: Merge Chained Aggregate Reads +debug: Optimizer: Replace Aggregate Box Ops +debug: Optimizer: Minimize Box Exist Asserts +debug: Optimizer: Constant Reads And Unobserved Writes Elimination +debug: Optimizing subroutine test_cases.structure_methods.contract.TestStruct.return_value_times +debug: Optimizer: Perform Subroutine Inlining +debug: Optimizer: Split Parallel Copies +debug: Optimizer: Constant Replacer +debug: Optimizer: Copy Propagation +debug: Found equivalence set: aggregate%extract%0#0, tuple_item%0#0 +debug: selected aggregate%extract%0#0 from equivalence set +debug: Copy propagation made 1 modifications +debug: Optimizer: Elide Itxn Field Calls +debug: Optimizer: Remove Unused Variables +debug: Optimizer: Intrinsic Simplifier +debug: Simplified (btoi aggregate%extract%0#0) to (extract_uint64 self#0 0u) +debug: Simplified (extract3 self#0 0u 8u) to ((extract 0 8) self#0) +debug: Optimizer: Inner Txn Field Replacer +debug: Optimizer: Replace Compiled References +debug: Optimizer: Simplify Control Ops +debug: Optimizer: Merge Blocks +debug: Optimizer: Remove Linear Jumps +debug: Optimizer: Remove Unreachable Blocks +debug: Optimizer: Repeated Expression Elimination +debug: Optimizer: Encode Decode Pair Elimination +debug: Optimizer: Merge Chained Aggregate Reads +debug: Optimizer: Replace Aggregate Box Ops +debug: Optimizer: Minimize Box Exist Asserts +debug: Optimizer: Constant Reads And Unobserved Writes Elimination +debug: Optimizing subroutine test_cases.structure_methods.contract.GroupedMethods.never_inlined_usually_inlined +debug: Optimizer: Perform Subroutine Inlining +debug: Optimizer: Split Parallel Copies +debug: Optimizer: Constant Replacer +debug: Optimizer: Copy Propagation +debug: Optimizer: Elide Itxn Field Calls +debug: Optimizer: Remove Unused Variables +debug: Optimizer: Intrinsic Simplifier +debug: Optimizer: Inner Txn Field Replacer +debug: Optimizer: Replace Compiled References +debug: Optimizer: Simplify Control Ops +debug: Optimizer: Merge Blocks +debug: Optimizer: Remove Linear Jumps +debug: Optimizer: Remove Unreachable Blocks +debug: Optimizer: Repeated Expression Elimination +debug: Optimizer: Encode Decode Pair Elimination +debug: Optimizer: Merge Chained Aggregate Reads +debug: Optimizer: Replace Aggregate Box Ops +debug: Optimizer: Minimize Box Exist Asserts +debug: Optimizer: Constant Reads And Unobserved Writes Elimination +debug: Optimizing subroutine test_cases.structure_methods.contract.GroupedMethods.not_usually_inlined +debug: Optimizer: Perform Subroutine Inlining +debug: Optimizer: Split Parallel Copies +debug: Optimizer: Constant Replacer +debug: Optimizer: Copy Propagation +debug: Found equivalence set: aggregate%val_as_bytes%0#0, aggregate%as_Encoded(uint64)%0#0, tmp%0#0 +debug: selected aggregate%val_as_bytes%0#0 from equivalence set +debug: Found equivalence set: aggregate%head%0#0, aggregate%as_Encoded(uint64)%1#0, tmp%1#0 +debug: selected aggregate%head%0#0 from equivalence set +debug: Copy propagation made 2 modifications +debug: Optimizer: Elide Itxn Field Calls +debug: Optimizer: Remove Unused Variables +debug: Optimizer: Intrinsic Simplifier +debug: Simplified (concat 0x aggregate%val_as_bytes%0#0) to aggregate%val_as_bytes%0#0 +debug: Optimizer: Inner Txn Field Replacer +debug: Optimizer: Replace Compiled References +debug: Optimizer: Simplify Control Ops +debug: Optimizer: Merge Blocks +debug: Optimizer: Remove Linear Jumps +debug: Optimizer: Remove Unreachable Blocks +debug: Optimizer: Repeated Expression Elimination +debug: Optimizer: Encode Decode Pair Elimination +debug: Optimizer: Merge Chained Aggregate Reads +debug: Optimizer: Replace Aggregate Box Ops +debug: Optimizer: Minimize Box Exist Asserts +debug: Optimizer: Constant Reads And Unobserved Writes Elimination +debug: Optimizing subroutine test_cases.structure_methods.contract.TestContract.test[routing] +debug: Optimizer: Perform Subroutine Inlining +structure_methods/contract.py:73:30 debug: inlining call to test_cases.structure_methods.contract.ARC4TestStruct.return_value_times in test_cases.structure_methods.contract.TestContract.test[routing] +structure_methods/contract.py:74:30 debug: inlining call to test_cases.structure_methods.contract.TestStruct.return_value_times in test_cases.structure_methods.contract.TestContract.test[routing] +structure_methods/contract.py:78:30 debug: inlining call to test_cases.structure_methods.contract.ARC4TestStruct.return_value_times in test_cases.structure_methods.contract.TestContract.test[routing] +structure_methods/contract.py:81:30 debug: inlining call to test_cases.structure_methods.contract.TestStruct.return_value_times in test_cases.structure_methods.contract.TestContract.test[routing] +debug: Optimizer: Split Parallel Copies +debug: Optimizer: Constant Replacer +debug: Optimizer: Copy Propagation +debug: Found equivalence set: aggregate%head%0#0, aggregate%as_Encoded(uint64)%0#0, tmp%0#0, self#0, return_value_times%1#0, self#2, return_value_times%5#0 +debug: selected self#0 from equivalence set +debug: Found equivalence set: tmp%1#2, return_value_times%0#0 +debug: selected tmp%1#2 from equivalence set +debug: Found equivalence set: aggregate%val_as_bytes%0#0, aggregate%as_Encoded(uint64)%1#0 +debug: selected aggregate%val_as_bytes%0#0 from equivalence set +debug: Found equivalence set: aggregate%head%1#0, aggregate%as_Encoded(uint64)%2#0, tmp%2#0, self#1, return_value_times%3#0, self#3, return_value_times%7#0 +debug: selected self#1 from equivalence set +debug: Found equivalence set: tmp%0#3, return_value_times%2#0 +debug: selected tmp%0#3 from equivalence set +debug: Found equivalence set: tmp%1#3, return_value_times%4#0 +debug: selected tmp%1#3 from equivalence set +debug: Found equivalence set: tmp%0#5, return_value_times%6#0 +debug: selected tmp%0#5 from equivalence set +debug: Found equivalence set: aggregate%val_as_bytes%1#0, aggregate%as_Encoded(uint64)%3#0, tmp%0#1 +debug: selected aggregate%val_as_bytes%1#0 from equivalence set +debug: Found equivalence set: aggregate%head%2#0, aggregate%as_Encoded(uint64)%4#0, tmp%1#1 +debug: selected aggregate%head%2#0 from equivalence set +debug: Copy propagation made 13 modifications +debug: Optimizer: Elide Itxn Field Calls +debug: Optimizer: Remove Unused Variables +debug: Removing unused variable times#0 +debug: Removing unused variable aggregate%extract%0#0 +debug: Removing unused variable times#1 +debug: Removing unused variable aggregate%extract%0#1 +debug: Removing unused variable times#2 +debug: Removing unused variable aggregate%extract%0#2 +debug: Removing unused variable times#3 +debug: Removing unused variable aggregate%extract%0#3 +debug: Optimizer: Intrinsic Simplifier +debug: Simplified (concat 0x 0x0000000000000009) to 0x0000000000000009 +debug: Simplified (extract_uint64 0x0000000000000009 0u) to 9u +debug: Simplified (* 9u 2u) to 18u +debug: Simplified (== 18u 18u) to 1u +debug: Simplified (concat 0x aggregate%val_as_bytes%0#0) to aggregate%val_as_bytes%0#0 +debug: Simplified (extract_uint64 aggregate%val_as_bytes%0#0 0u) to 9u +debug: Simplified (* 9u 2u) to 18u +debug: Simplified (== 18u 18u) to 1u +debug: Simplified (extract_uint64 0x0000000000000009 0u) to 9u +debug: Simplified (* 9u 2u) to 18u +debug: Simplified (== 18u 18u) to 1u +debug: Simplified (extract_uint64 aggregate%val_as_bytes%0#0 0u) to 9u +debug: Simplified (* 9u 2u) to 18u +debug: Simplified (== 18u 18u) to 1u +debug: Simplified (concat 0x aggregate%val_as_bytes%1#0) to aggregate%val_as_bytes%1#0 +debug: Simplified (concat method "ARC4TestStruct(uint64)" aggregate%val_as_bytes%1#0) to 0xed3267e80000000000000002 +debug: Optimizer: Inner Txn Field Replacer +debug: Optimizer: Replace Compiled References +debug: Optimizer: Simplify Control Ops +debug: Optimizer: Merge Blocks +debug: Replaced predecessor block@1 with block@0 in block@2 +debug: Merged linear block@1 into block@0 +debug: Replaced predecessor block@2 with block@0 in block@3 +debug: Merged linear block@2 into block@0 +debug: Replaced predecessor block@3 with block@0 in block@4 +debug: Merged linear block@3 into block@0 +debug: Replaced predecessor block@4 with block@0 in block@5 +debug: Merged linear block@4 into block@0 +debug: Replaced predecessor block@5 with block@0 in block@6 +debug: Merged linear block@5 into block@0 +debug: Replaced predecessor block@6 with block@0 in block@7 +debug: Merged linear block@6 into block@0 +debug: Replaced predecessor block@7 with block@0 in block@8 +debug: Merged linear block@7 into block@0 +debug: Merged linear block@8 into block@0 +debug: Optimizer: Remove Linear Jumps +debug: Optimizer: Remove Unreachable Blocks +debug: Optimizer: Repeated Expression Elimination +debug: Optimizer: Encode Decode Pair Elimination +debug: Optimizer: Merge Chained Aggregate Reads +debug: Optimizer: Replace Aggregate Box Ops +debug: Optimizer: Minimize Box Exist Asserts +debug: Optimizer: Constant Reads And Unobserved Writes Elimination +debug: removing unused subroutine test_cases.structure_methods.contract.ARC4TestStruct.return_value_times +debug: removing unused subroutine test_cases.structure_methods.contract.TestStruct.return_value_times +debug: Unused subroutines removed +debug: Output IR to structure_methods/out/TestContract.ir/TestContract.approval.200.ssa.array.opt.ir +debug: Begin optimization pass 2/100 +debug: Optimizing subroutine algopy.arc4.ARC4Contract.approval_program +debug: Optimizer: Perform Subroutine Inlining +debug: Optimizer: Split Parallel Copies +debug: Optimizer: Constant Replacer +debug: Optimizer: Copy Propagation +debug: Optimizer: Elide Itxn Field Calls +debug: Optimizer: Remove Unused Variables +debug: Optimizer: Intrinsic Simplifier +debug: Optimizer: Inner Txn Field Replacer +debug: Optimizer: Replace Compiled References +debug: Optimizer: Simplify Control Ops +debug: Optimizer: Merge Blocks +debug: Optimizer: Remove Linear Jumps +debug: Optimizer: Remove Unreachable Blocks +debug: Optimizer: Repeated Expression Elimination +debug: Optimizer: Encode Decode Pair Elimination +debug: Optimizer: Merge Chained Aggregate Reads +debug: Optimizer: Replace Aggregate Box Ops +debug: Optimizer: Minimize Box Exist Asserts +debug: Optimizer: Constant Reads And Unobserved Writes Elimination +debug: Optimizing subroutine test_cases.structure_methods.contract.GroupedMethods.never_inlined_usually_inlined +debug: Optimizer: Perform Subroutine Inlining +debug: Optimizer: Split Parallel Copies +debug: Optimizer: Constant Replacer +debug: Optimizer: Copy Propagation +debug: Optimizer: Elide Itxn Field Calls +debug: Optimizer: Remove Unused Variables +debug: Optimizer: Intrinsic Simplifier +debug: Optimizer: Inner Txn Field Replacer +debug: Optimizer: Replace Compiled References +debug: Optimizer: Simplify Control Ops +debug: Optimizer: Merge Blocks +debug: Optimizer: Remove Linear Jumps +debug: Optimizer: Remove Unreachable Blocks +debug: Optimizer: Repeated Expression Elimination +debug: Optimizer: Encode Decode Pair Elimination +debug: Optimizer: Merge Chained Aggregate Reads +debug: Optimizer: Replace Aggregate Box Ops +debug: Optimizer: Minimize Box Exist Asserts +debug: Optimizer: Constant Reads And Unobserved Writes Elimination +debug: Optimizing subroutine test_cases.structure_methods.contract.GroupedMethods.not_usually_inlined +debug: Optimizer: Perform Subroutine Inlining +debug: Optimizer: Split Parallel Copies +debug: Optimizer: Constant Replacer +debug: Optimizer: Copy Propagation +debug: Found equivalence set: aggregate%val_as_bytes%0#0, aggregate%head%0#0 +debug: selected aggregate%val_as_bytes%0#0 from equivalence set +debug: Optimizer: Elide Itxn Field Calls +debug: Optimizer: Remove Unused Variables +debug: Optimizer: Intrinsic Simplifier +debug: Optimizer: Inner Txn Field Replacer +debug: Optimizer: Replace Compiled References +debug: Optimizer: Simplify Control Ops +debug: Optimizer: Merge Blocks +debug: Optimizer: Remove Linear Jumps +debug: Optimizer: Remove Unreachable Blocks +debug: Optimizer: Repeated Expression Elimination +debug: Optimizer: Encode Decode Pair Elimination +debug: Optimizer: Merge Chained Aggregate Reads +debug: Optimizer: Replace Aggregate Box Ops +debug: Optimizer: Minimize Box Exist Asserts +debug: Optimizer: Constant Reads And Unobserved Writes Elimination +debug: Optimizing subroutine test_cases.structure_methods.contract.TestContract.test[routing] +debug: Optimizer: Perform Subroutine Inlining +debug: Optimizer: Split Parallel Copies +debug: Optimizer: Constant Replacer +debug: Optimizer: Copy Propagation +debug: Found equivalence set: aggregate%val_as_bytes%0#0, self#1 +debug: selected self#1 from equivalence set +debug: Found equivalence set: aggregate%val_as_bytes%1#0, aggregate%head%2#0 +debug: selected aggregate%val_as_bytes%1#0 from equivalence set +debug: Copy propagation made 1 modifications +debug: Optimizer: Elide Itxn Field Calls +debug: Optimizer: Remove Unused Variables +debug: Removing unused variable self#0 +debug: Removing unused variable tmp%0#2 +debug: Removing unused variable tmp%1#2 +debug: Removing unused variable tmp%1#0 +debug: Removing unused variable self#1 +debug: Removing unused variable values%0#0 +debug: Removing unused variable tmp%0#3 +debug: Removing unused variable tmp%3#0 +debug: Removing unused variable tmp%0#4 +debug: Removing unused variable tmp%1#3 +debug: Removing unused variable tmp%7#0 +debug: Removing unused variable values%0#1 +debug: Removing unused variable tmp%0#5 +debug: Removing unused variable tmp%9#0 +debug: Removing unused variable aggregate%val_as_bytes%1#0 +debug: Removing unused variable event%0#0 +debug: Optimizer: Intrinsic Simplifier +debug: Optimizer: Inner Txn Field Replacer +debug: Optimizer: Replace Compiled References +debug: Optimizer: Simplify Control Ops +debug: Optimizer: Merge Blocks +debug: Optimizer: Remove Linear Jumps +debug: Optimizer: Remove Unreachable Blocks +debug: Optimizer: Repeated Expression Elimination +debug: Optimizer: Encode Decode Pair Elimination +debug: Optimizer: Merge Chained Aggregate Reads +debug: Optimizer: Replace Aggregate Box Ops +debug: Optimizer: Minimize Box Exist Asserts +debug: Optimizer: Constant Reads And Unobserved Writes Elimination +debug: Output IR to structure_methods/out/TestContract.ir/TestContract.approval.201.ssa.array.opt.ir +debug: Begin optimization pass 3/100 +debug: Optimizing subroutine algopy.arc4.ARC4Contract.approval_program +debug: Optimizer: Perform Subroutine Inlining +debug: Optimizer: Split Parallel Copies +debug: Optimizer: Constant Replacer +debug: Optimizer: Copy Propagation +debug: Optimizer: Elide Itxn Field Calls +debug: Optimizer: Remove Unused Variables +debug: Optimizer: Intrinsic Simplifier +debug: Optimizer: Inner Txn Field Replacer +debug: Optimizer: Replace Compiled References +debug: Optimizer: Simplify Control Ops +debug: Optimizer: Merge Blocks +debug: Optimizer: Remove Linear Jumps +debug: Optimizer: Remove Unreachable Blocks +debug: Optimizer: Repeated Expression Elimination +debug: Optimizer: Encode Decode Pair Elimination +debug: Optimizer: Merge Chained Aggregate Reads +debug: Optimizer: Replace Aggregate Box Ops +debug: Optimizer: Minimize Box Exist Asserts +debug: Optimizer: Constant Reads And Unobserved Writes Elimination +debug: Optimizing subroutine test_cases.structure_methods.contract.GroupedMethods.never_inlined_usually_inlined +debug: Optimizer: Perform Subroutine Inlining +debug: Optimizer: Split Parallel Copies +debug: Optimizer: Constant Replacer +debug: Optimizer: Copy Propagation +debug: Optimizer: Elide Itxn Field Calls +debug: Optimizer: Remove Unused Variables +debug: Optimizer: Intrinsic Simplifier +debug: Optimizer: Inner Txn Field Replacer +debug: Optimizer: Replace Compiled References +debug: Optimizer: Simplify Control Ops +debug: Optimizer: Merge Blocks +debug: Optimizer: Remove Linear Jumps +debug: Optimizer: Remove Unreachable Blocks +debug: Optimizer: Repeated Expression Elimination +debug: Optimizer: Encode Decode Pair Elimination +debug: Optimizer: Merge Chained Aggregate Reads +debug: Optimizer: Replace Aggregate Box Ops +debug: Optimizer: Minimize Box Exist Asserts +debug: Optimizer: Constant Reads And Unobserved Writes Elimination +debug: Optimizing subroutine test_cases.structure_methods.contract.GroupedMethods.not_usually_inlined +debug: Optimizer: Perform Subroutine Inlining +debug: Optimizer: Split Parallel Copies +debug: Optimizer: Constant Replacer +debug: Optimizer: Copy Propagation +debug: Optimizer: Elide Itxn Field Calls +debug: Optimizer: Remove Unused Variables +debug: Optimizer: Intrinsic Simplifier +debug: Optimizer: Inner Txn Field Replacer +debug: Optimizer: Replace Compiled References +debug: Optimizer: Simplify Control Ops +debug: Optimizer: Merge Blocks +debug: Optimizer: Remove Linear Jumps +debug: Optimizer: Remove Unreachable Blocks +debug: Optimizer: Repeated Expression Elimination +debug: Optimizer: Encode Decode Pair Elimination +debug: Optimizer: Merge Chained Aggregate Reads +debug: Optimizer: Replace Aggregate Box Ops +debug: Optimizer: Minimize Box Exist Asserts +debug: Optimizer: Constant Reads And Unobserved Writes Elimination +debug: Optimizing subroutine test_cases.structure_methods.contract.TestContract.test[routing] +debug: Optimizer: Perform Subroutine Inlining +debug: Optimizer: Split Parallel Copies +debug: Optimizer: Constant Replacer +debug: Optimizer: Copy Propagation +debug: Optimizer: Elide Itxn Field Calls +debug: Optimizer: Remove Unused Variables +debug: Optimizer: Intrinsic Simplifier +debug: Optimizer: Inner Txn Field Replacer +debug: Optimizer: Replace Compiled References +debug: Optimizer: Simplify Control Ops +debug: Optimizer: Merge Blocks +debug: Optimizer: Remove Linear Jumps +debug: Optimizer: Remove Unreachable Blocks +debug: Optimizer: Repeated Expression Elimination +debug: Optimizer: Encode Decode Pair Elimination +debug: Optimizer: Merge Chained Aggregate Reads +debug: Optimizer: Replace Aggregate Box Ops +debug: Optimizer: Minimize Box Exist Asserts +debug: Optimizer: Constant Reads And Unobserved Writes Elimination +debug: No optimizations performed in pass 3, ending loop +debug: optimizing clear program of test_cases.structure_methods.contract.TestContract at level 1 +debug: Begin optimization pass 1/100 +debug: Optimizing subroutine algopy.arc4.ARC4Contract.clear_state_program +debug: Optimizer: Perform Subroutine Inlining +debug: Optimizer: Split Parallel Copies +debug: Optimizer: Constant Replacer +debug: Optimizer: Copy Propagation +debug: Optimizer: Elide Itxn Field Calls +debug: Optimizer: Remove Unused Variables +debug: Optimizer: Intrinsic Simplifier +debug: Optimizer: Inner Txn Field Replacer +debug: Optimizer: Replace Compiled References +debug: Optimizer: Simplify Control Ops +debug: Optimizer: Merge Blocks +debug: Optimizer: Remove Linear Jumps +debug: Optimizer: Remove Unreachable Blocks +debug: Optimizer: Repeated Expression Elimination +debug: Optimizer: Encode Decode Pair Elimination +debug: Optimizer: Merge Chained Aggregate Reads +debug: Optimizer: Replace Aggregate Box Ops +debug: Optimizer: Minimize Box Exist Asserts +debug: Optimizer: Constant Reads And Unobserved Writes Elimination +debug: No optimizations performed in pass 1, ending loop +debug: removing local static slots in approval program of test_cases.structure_methods.contract.TestContract +debug: auto reserving slots in algopy.arc4.ARC4Contract.approval_program, [] +structure_methods/contract.py:40:6 debug: auto reserving slots in test_cases.structure_methods.contract.GroupedMethods.never_inlined_usually_inlined, [] +structure_methods/contract.py:58:5 debug: auto reserving slots in test_cases.structure_methods.contract.GroupedMethods.not_usually_inlined, [] +structure_methods/contract.py:70:6 debug: auto reserving slots in test_cases.structure_methods.contract.TestContract.test[routing], [] +debug: Slot allocation not required +debug: Output IR to structure_methods/out/TestContract.ir/TestContract.approval.300.ssa.slot.ir +debug: removing local static slots in clear program of test_cases.structure_methods.contract.TestContract +debug: auto reserving slots in algopy.arc4.ARC4Contract.clear_state_program, [] +debug: Slot allocation not required +debug: Output IR to structure_methods/out/TestContract.ir/TestContract.clear.300.ssa.slot.ir +debug: Performing SSA IR destructuring for algopy.arc4.ARC4Contract.approval_program +debug: splitting critical edge block@2->block@4 +debug: Replaced predecessor block@2 with block@6 in block@4 +debug: Converting to CSSA +debug: Removing Phi nodes +debug: Coalescing local variables in algopy.arc4.ARC4Contract.approval_program using strategy 'root_operand' +debug: Coalescing resulted in 0 replacement/s +debug: Sequentializing parallel copies in algopy.arc4.ARC4Contract.approval_program +debug: Performing post-SSA optimizations at level 1 +debug: Removing jump block block@6 +debug: branching to block@6 will be replaced with block@4 +debug: Performing SSA IR destructuring for test_cases.structure_methods.contract.GroupedMethods.never_inlined_usually_inlined +debug: Converting to CSSA +debug: Removing Phi nodes +debug: Coalescing local variables in test_cases.structure_methods.contract.GroupedMethods.never_inlined_usually_inlined using strategy 'root_operand' +debug: Coalescing resulted in 0 replacement/s +debug: Sequentializing parallel copies in test_cases.structure_methods.contract.GroupedMethods.never_inlined_usually_inlined +debug: Performing post-SSA optimizations at level 1 +debug: Performing SSA IR destructuring for test_cases.structure_methods.contract.GroupedMethods.not_usually_inlined +debug: Converting to CSSA +debug: Removing Phi nodes +debug: Coalescing local variables in test_cases.structure_methods.contract.GroupedMethods.not_usually_inlined using strategy 'root_operand' +debug: Coalescing resulted in 0 replacement/s +debug: Sequentializing parallel copies in test_cases.structure_methods.contract.GroupedMethods.not_usually_inlined +debug: Performing post-SSA optimizations at level 1 +debug: Performing SSA IR destructuring for test_cases.structure_methods.contract.TestContract.test[routing] +debug: Converting to CSSA +debug: Removing Phi nodes +debug: Coalescing local variables in test_cases.structure_methods.contract.TestContract.test[routing] using strategy 'root_operand' +debug: Coalescing resulted in 0 replacement/s +debug: Sequentializing parallel copies in test_cases.structure_methods.contract.TestContract.test[routing] +debug: Performing post-SSA optimizations at level 1 +debug: Output IR to structure_methods/out/TestContract.ir/TestContract.approval.400.destructured.ir +debug: Performing SSA IR destructuring for algopy.arc4.ARC4Contract.clear_state_program +debug: Converting to CSSA +debug: Removing Phi nodes +debug: Coalescing local variables in algopy.arc4.ARC4Contract.clear_state_program using strategy 'root_operand' +debug: Coalescing resulted in 0 replacement/s +debug: Sequentializing parallel copies in algopy.arc4.ARC4Contract.clear_state_program +debug: Performing post-SSA optimizations at level 1 +debug: Output IR to structure_methods/out/TestContract.ir/TestContract.clear.400.destructured.ir +debug: Inserted main_block@0.ops[1]: 'l-store-copy tmp%0#1 0' +debug: Replaced main_block@0.ops[3]: 'v-load tmp%0#1' with 'l-load tmp%0#1' +debug: Inserted main_abi_routing@2.ops[1]: 'l-store-copy tmp%2#0 0' +debug: Replaced main_abi_routing@2.ops[4]: 'v-load tmp%2#0' with 'l-load tmp%2#0' +debug: Inserted main_test_route@3.ops[1]: 'l-store-copy tmp%3#0 0' +debug: Replaced main_test_route@3.ops[3]: 'v-load tmp%3#0' with 'l-load tmp%3#0' +debug: Inserted main_test_route@3.ops[11]: 'l-store-copy tmp%7#0 0' +debug: Replaced main_test_route@3.ops[13]: 'v-load tmp%7#0' with 'l-load tmp%7#0' +debug: Inserted main_test_route@3.ops[7]: 'l-store-copy tmp%5#0 0' +debug: Replaced main_test_route@3.ops[10]: 'v-load tmp%5#0' with 'l-load tmp%5#0' +debug: Inserted main_test_route@3.ops[5]: 'l-store-copy tmp%4#0 0' +debug: Replaced main_test_route@3.ops[10]: 'v-load tmp%4#0' with 'l-load tmp%4#0' +debug: Inserted main___algopy_default_create@5.ops[1]: 'l-store-copy tmp%8#0 0' +debug: Replaced main___algopy_default_create@5.ops[3]: 'v-load tmp%8#0' with 'l-load tmp%8#0' +debug: Inserted main___algopy_default_create@5.ops[7]: 'l-store-copy tmp%10#0 0' +debug: Replaced main___algopy_default_create@5.ops[9]: 'v-load tmp%10#0' with 'l-load tmp%10#0' +debug: Inserted main___algopy_default_create@5.ops[15]: 'l-store-copy tmp%12#0 0' +debug: Replaced main___algopy_default_create@5.ops[17]: 'v-load tmp%12#0' with 'l-load tmp%12#0' +debug: Inserted main___algopy_default_create@5.ops[11]: 'l-store-copy tmp%11#0 0' +debug: Replaced main___algopy_default_create@5.ops[14]: 'v-load tmp%11#0' with 'l-load tmp%11#0' +debug: Inserted main___algopy_default_create@5.ops[5]: 'l-store-copy tmp%9#0 0' +debug: Replaced main___algopy_default_create@5.ops[14]: 'v-load tmp%9#0' with 'l-load tmp%9#0' +debug: Inserted never_inlined_usually_inlined_block@0.ops[3]: 'l-store-copy tmp%0#0 0' +debug: Replaced never_inlined_usually_inlined_block@0.ops[5]: 'v-load tmp%0#0' with 'l-load tmp%0#0' +debug: Inserted not_usually_inlined_block@0.ops[6]: 'l-store-copy event%0#0 0' +debug: Replaced not_usually_inlined_block@0.ops[8]: 'v-load event%0#0' with 'l-load event%0#0' +debug: Inserted not_usually_inlined_block@0.ops[2]: 'l-store-copy aggregate%val_as_bytes%0#0 0' +debug: Replaced not_usually_inlined_block@0.ops[5]: 'v-load aggregate%val_as_bytes%0#0' with 'l-load aggregate%val_as_bytes%0#0' +debug: Inserted not_usually_inlined_block@0.ops[10]: 'l-store-copy event%0#0 0' +debug: Replaced not_usually_inlined_block@0.ops[12]: 'v-load event%0#0' with 'l-load event%0#0' +debug: Inserted not_usually_inlined_block@0.ops[13]: 'l-store-copy event%0#0 0' +debug: Replaced not_usually_inlined_block@0.ops[15]: 'v-load event%0#0' with 'l-load event%0#0' +debug: Inserted not_usually_inlined_block@0.ops[16]: 'l-store-copy event%0#0 0' +debug: Replaced not_usually_inlined_block@0.ops[18]: 'v-load event%0#0' with 'l-load event%0#0' +debug: Inserted not_usually_inlined_block@0.ops[19]: 'l-store-copy event%0#0 0' +debug: Replaced not_usually_inlined_block@0.ops[21]: 'v-load event%0#0' with 'l-load event%0#0' +debug: Inserted not_usually_inlined_block@0.ops[22]: 'l-store-copy event%0#0 0' +debug: Replaced not_usually_inlined_block@0.ops[24]: 'v-load event%0#0' with 'l-load event%0#0' +debug: Inserted not_usually_inlined_block@0.ops[25]: 'l-store-copy event%0#0 0' +debug: Replaced not_usually_inlined_block@0.ops[27]: 'v-load event%0#0' with 'l-load event%0#0' +debug: Inserted not_usually_inlined_block@0.ops[28]: 'l-store-copy event%0#0 0' +debug: Replaced not_usually_inlined_block@0.ops[30]: 'v-load event%0#0' with 'l-load event%0#0' +debug: Inserted test_block@0.ops[6]: 'l-store-copy tmp%25#0 0' +debug: Replaced test_block@0.ops[8]: 'v-load tmp%25#0' with 'l-load tmp%25#0' +debug: Inserted test_block@0.ops[16]: 'l-store-copy tmp%27#0 0' +debug: Replaced test_block@0.ops[18]: 'v-load tmp%27#0' with 'l-load tmp%27#0' +debug: Inserted test_block@0.ops[2]: 'l-store-copy tmp%24#0 0' +debug: Replaced test_block@0.ops[5]: 'v-load tmp%24#0' with 'l-load tmp%24#0' +debug: Inserted test_block@0.ops[13]: 'l-store-copy tmp%26#0 0' +debug: Replaced test_block@0.ops[16]: 'v-load tmp%26#0' with 'l-load tmp%26#0' +debug: Found 2 edge set/s for algopy.arc4.ARC4Contract.approval_program +debug: optimizing TEAL subroutine ops algopy.arc4.ARC4Contract.approval_program() -> uint64: +structure_methods/contract.py:40:6 debug: optimizing TEAL subroutine ops test_cases.structure_methods.contract.GroupedMethods.never_inlined_usually_inlined(v: uint64) -> uint64: +structure_methods/contract.py:58:5 debug: optimizing TEAL subroutine ops test_cases.structure_methods.contract.GroupedMethods.not_usually_inlined(v: uint64) -> void: +structure_methods/contract.py:70:6 debug: optimizing TEAL subroutine ops test_cases.structure_methods.contract.TestContract.test[routing]() -> void: +debug: optimizing TEAL subroutine blocks algopy.arc4.ARC4Contract.approval_program() -> uint64: +debug: replacing `b main_switch_case_next@4` with `err` +debug: inlining single reference block main_block@0 into main +debug: inlining single reference block main_abi_routing@2 into main +debug: inlining single reference block main_switch_case_next@4 into main +structure_methods/contract.py:40:6 debug: optimizing TEAL subroutine blocks test_cases.structure_methods.contract.GroupedMethods.never_inlined_usually_inlined(v: uint64) -> uint64: +debug: inlining single reference block never_inlined_usually_inlined_block@0 into never_inlined_usually_inlined +structure_methods/contract.py:58:5 debug: optimizing TEAL subroutine blocks test_cases.structure_methods.contract.GroupedMethods.not_usually_inlined(v: uint64) -> void: +debug: inlining single reference block not_usually_inlined_block@0 into not_usually_inlined +structure_methods/contract.py:70:6 debug: optimizing TEAL subroutine blocks test_cases.structure_methods.contract.TestContract.test[routing]() -> void: +debug: inlining single reference block test_block@0 into test +debug: optimizing TEAL subroutine ops algopy.arc4.ARC4Contract.clear_state_program() -> uint64: +debug: optimizing TEAL subroutine blocks algopy.arc4.ARC4Contract.clear_state_program() -> uint64: +debug: inlining single reference block main_block@0 into main +info: Writing structure_methods/out/TestContract.arc56.json +info: Writing structure_methods/out/TestContract.approval.teal +info: Writing structure_methods/out/TestContract.clear.teal +info: Writing structure_methods/out/TestContract.approval.bin +info: Writing structure_methods/out/TestContract.clear.bin +info: Writing structure_methods/out/TestContract.approval.stats.txt +info: Writing structure_methods/out/TestContract.clear.stats.txt +info: Writing structure_methods/out/TestContract.approval.puya.map +info: Writing structure_methods/out/TestContract.clear.puya.map +info: writing structure_methods/out/client_TestContract.py \ No newline at end of file diff --git a/test_cases/structure_methods/puya_O2.log b/test_cases/structure_methods/puya_O2.log new file mode 100644 index 0000000000..8b10c527eb --- /dev/null +++ b/test_cases/structure_methods/puya_O2.log @@ -0,0 +1,2485 @@ +debug: PuyaPyOptions(output_teal=True, output_source_map=True, output_arc32=False, output_arc56=False, output_ssa_ir=False, output_optimization_ir=False, output_destructured_ir=True, output_memory_ir=False, output_bytecode=True, output_teal_intermediates=False, output_op_statistics=True, debug_level=0, optimization_level=2, target_avm_version=11, cli_template_definitions={}, template_vars_prefix='TMPL_', locals_coalescing_strategy=, optimizations_override=immutabledict({}), expand_all_bytes=False, validate_abi_args=True, validate_abi_return=True, paths=['structure_methods'], resource_encoding='value', output_awst=False, output_awst_json=False, output_source_annotations_json=False, output_client=False, log_level=) +debug: Building IR for function _puya_lib.util.ensure_budget +debug: Sealing block@0 +debug: Terminated block@0 +debug: Looking for 'required_budget_with_buffer' in an unsealed block creating an incomplete Phi: block@1 +debug: Created Phi assignment: let required_budget_with_buffer#1: uint64 = undefined while trying to resolve 'required_budget_with_buffer' in block@1 +debug: Terminated block@1 +debug: Sealing block@2 +debug: Looking for 'fee_source' in an unsealed block creating an incomplete Phi: block@1 +debug: Created Phi assignment: let fee_source#1: uint64 = undefined while trying to resolve 'fee_source' in block@1 +debug: Terminated block@2 +debug: Terminated block@3 +debug: Terminated block@4 +debug: Sealing block@5 +debug: Terminated block@5 +debug: Sealing block@1 +debug: Added required_budget_with_buffer#0 to Phi node: let required_budget_with_buffer#1: uint64 = φ(required_budget_with_buffer#0 <- block@0) in block@0 +debug: Created Phi assignment: let required_budget_with_buffer#2: uint64 = undefined while trying to resolve 'required_budget_with_buffer' in block@5 +debug: Added required_budget_with_buffer#1 to Phi node: let required_budget_with_buffer#2: uint64 = φ(required_budget_with_buffer#1 <- block@2) in block@2 +debug: Looking for 'required_budget_with_buffer' in an unsealed block creating an incomplete Phi: block@3 +debug: Created Phi assignment: let required_budget_with_buffer#3: uint64 = undefined while trying to resolve 'required_budget_with_buffer' in block@3 +debug: Added required_budget_with_buffer#3 to Phi node: let required_budget_with_buffer#2: uint64 = φ(required_budget_with_buffer#1 <- block@2, required_budget_with_buffer#3 <- block@3) in block@3 +debug: Looking for 'required_budget_with_buffer' in an unsealed block creating an incomplete Phi: block@4 +debug: Created Phi assignment: let required_budget_with_buffer#4: uint64 = undefined while trying to resolve 'required_budget_with_buffer' in block@4 +debug: Added required_budget_with_buffer#4 to Phi node: let required_budget_with_buffer#2: uint64 = φ(required_budget_with_buffer#1 <- block@2, required_budget_with_buffer#3 <- block@3, required_budget_with_buffer#4 <- block@4) in block@4 +debug: Added required_budget_with_buffer#2 to Phi node: let required_budget_with_buffer#1: uint64 = φ(required_budget_with_buffer#0 <- block@0, required_budget_with_buffer#2 <- block@5) in block@5 +debug: Added fee_source#0 to Phi node: let fee_source#1: uint64 = φ(fee_source#0 <- block@0) in block@0 +debug: Created Phi assignment: let fee_source#2: uint64 = undefined while trying to resolve 'fee_source' in block@5 +debug: Added fee_source#1 to Phi node: let fee_source#2: uint64 = φ(fee_source#1 <- block@2) in block@2 +debug: Looking for 'fee_source' in an unsealed block creating an incomplete Phi: block@3 +debug: Created Phi assignment: let fee_source#3: uint64 = undefined while trying to resolve 'fee_source' in block@3 +debug: Added fee_source#3 to Phi node: let fee_source#2: uint64 = φ(fee_source#1 <- block@2, fee_source#3 <- block@3) in block@3 +debug: Looking for 'fee_source' in an unsealed block creating an incomplete Phi: block@4 +debug: Created Phi assignment: let fee_source#4: uint64 = undefined while trying to resolve 'fee_source' in block@4 +debug: Added fee_source#4 to Phi node: let fee_source#2: uint64 = φ(fee_source#1 <- block@2, fee_source#3 <- block@3, fee_source#4 <- block@4) in block@4 +debug: Added fee_source#2 to Phi node: let fee_source#1: uint64 = φ(fee_source#0 <- block@0, fee_source#2 <- block@5) in block@5 +debug: Sealing block@6 +debug: Terminated block@6 +debug: Sealing block@3 +debug: Added required_budget_with_buffer#1 to Phi node: let required_budget_with_buffer#3: uint64 = φ(required_budget_with_buffer#1 <- block@2) in block@2 +debug: Replacing trivial Phi node: let required_budget_with_buffer#3: uint64 = φ(required_budget_with_buffer#1 <- block@2) (required_budget_with_buffer#3) with required_budget_with_buffer#1 +debug: Deleting Phi assignment: let required_budget_with_buffer#3: uint64 = φ(required_budget_with_buffer#1 <- block@2) +debug: Replaced trivial Phi node: let required_budget_with_buffer#3: uint64 = φ(required_budget_with_buffer#1 <- block@2) (required_budget_with_buffer#3) with required_budget_with_buffer#1 in current definition for 1 blocks +debug: Added fee_source#1 to Phi node: let fee_source#3: uint64 = φ(fee_source#1 <- block@2) in block@2 +debug: Replacing trivial Phi node: let fee_source#3: uint64 = φ(fee_source#1 <- block@2) (fee_source#3) with fee_source#1 +debug: Deleting Phi assignment: let fee_source#3: uint64 = φ(fee_source#1 <- block@2) +debug: Replaced trivial Phi node: let fee_source#3: uint64 = φ(fee_source#1 <- block@2) (fee_source#3) with fee_source#1 in current definition for 1 blocks +debug: Sealing block@4 +debug: Added required_budget_with_buffer#1 to Phi node: let required_budget_with_buffer#4: uint64 = φ(required_budget_with_buffer#1 <- block@2) in block@2 +debug: Replacing trivial Phi node: let required_budget_with_buffer#4: uint64 = φ(required_budget_with_buffer#1 <- block@2) (required_budget_with_buffer#4) with required_budget_with_buffer#1 +debug: Deleting Phi assignment: let required_budget_with_buffer#4: uint64 = φ(required_budget_with_buffer#1 <- block@2) +debug: Replacing trivial Phi node: let required_budget_with_buffer#2: uint64 = φ(required_budget_with_buffer#1 <- block@2, required_budget_with_buffer#1 <- block@3, required_budget_with_buffer#1 <- block@4) (required_budget_with_buffer#2) with required_budget_with_buffer#1 +debug: Deleting Phi assignment: let required_budget_with_buffer#2: uint64 = φ(required_budget_with_buffer#1 <- block@2, required_budget_with_buffer#1 <- block@3, required_budget_with_buffer#1 <- block@4) +debug: Replacing trivial Phi node: let required_budget_with_buffer#1: uint64 = φ(required_budget_with_buffer#0 <- block@0, required_budget_with_buffer#1 <- block@5) (required_budget_with_buffer#1) with required_budget_with_buffer#0 +debug: Deleting Phi assignment: let required_budget_with_buffer#1: uint64 = φ(required_budget_with_buffer#0 <- block@0, required_budget_with_buffer#1 <- block@5) +debug: Replaced trivial Phi node: let required_budget_with_buffer#4: uint64 = φ(required_budget_with_buffer#1 <- block@2) (required_budget_with_buffer#4) with required_budget_with_buffer#1 in current definition for 1 blocks +debug: Replaced trivial Phi node: let required_budget_with_buffer#2: uint64 = φ(required_budget_with_buffer#1 <- block@2, required_budget_with_buffer#1 <- block@3, required_budget_with_buffer#1 <- block@4) (required_budget_with_buffer#2) with required_budget_with_buffer#1 in current definition for 1 blocks +debug: Replaced trivial Phi node: let required_budget_with_buffer#1: uint64 = φ(required_budget_with_buffer#0 <- block@0, required_budget_with_buffer#1 <- block@5) (required_budget_with_buffer#1) with required_budget_with_buffer#0 in current definition for 5 blocks +debug: Added fee_source#1 to Phi node: let fee_source#4: uint64 = φ(fee_source#1 <- block@2) in block@2 +debug: Replacing trivial Phi node: let fee_source#4: uint64 = φ(fee_source#1 <- block@2) (fee_source#4) with fee_source#1 +debug: Deleting Phi assignment: let fee_source#4: uint64 = φ(fee_source#1 <- block@2) +debug: Replacing trivial Phi node: let fee_source#2: uint64 = φ(fee_source#1 <- block@2, fee_source#1 <- block@3, fee_source#1 <- block@4) (fee_source#2) with fee_source#1 +debug: Deleting Phi assignment: let fee_source#2: uint64 = φ(fee_source#1 <- block@2, fee_source#1 <- block@3, fee_source#1 <- block@4) +debug: Replacing trivial Phi node: let fee_source#1: uint64 = φ(fee_source#0 <- block@0, fee_source#1 <- block@5) (fee_source#1) with fee_source#0 +debug: Deleting Phi assignment: let fee_source#1: uint64 = φ(fee_source#0 <- block@0, fee_source#1 <- block@5) +debug: Replaced trivial Phi node: let fee_source#4: uint64 = φ(fee_source#1 <- block@2) (fee_source#4) with fee_source#1 in current definition for 1 blocks +debug: Replaced trivial Phi node: let fee_source#2: uint64 = φ(fee_source#1 <- block@2, fee_source#1 <- block@3, fee_source#1 <- block@4) (fee_source#2) with fee_source#1 in current definition for 1 blocks +debug: Replaced trivial Phi node: let fee_source#1: uint64 = φ(fee_source#0 <- block@0, fee_source#1 <- block@5) (fee_source#1) with fee_source#0 in current definition for 5 blocks +debug: Building IR for function _puya_lib.bytes_.is_substring +debug: Sealing block@0 +debug: Terminated block@0 +debug: Looking for 'start' in an unsealed block creating an incomplete Phi: block@1 +debug: Created Phi assignment: let start#1: uint64 = undefined while trying to resolve 'start' in block@1 +debug: Looking for 'item' in an unsealed block creating an incomplete Phi: block@1 +debug: Created Phi assignment: let item#1: bytes = undefined while trying to resolve 'item' in block@1 +debug: Looking for 'sequence' in an unsealed block creating an incomplete Phi: block@1 +debug: Created Phi assignment: let sequence#1: bytes = undefined while trying to resolve 'sequence' in block@1 +debug: Terminated block@1 +debug: Sealing block@2 +debug: Terminated block@2 +debug: Sealing block@3 +debug: Terminated block@3 +debug: Sealing block@4 +debug: Terminated block@4 +debug: Sealing block@1 +debug: Added start#0 to Phi node: let start#1: uint64 = φ(start#0 <- block@0) in block@0 +debug: Added start#2 to Phi node: let start#1: uint64 = φ(start#0 <- block@0, start#2 <- block@4) in block@4 +debug: Added item#0 to Phi node: let item#1: bytes = φ(item#0 <- block@0) in block@0 +debug: Added item#1 to Phi node: let item#1: bytes = φ(item#0 <- block@0, item#1 <- block@4) in block@4 +debug: Replacing trivial Phi node: let item#1: bytes = φ(item#0 <- block@0, item#1 <- block@4) (item#1) with item#0 +debug: Deleting Phi assignment: let item#1: bytes = φ(item#0 <- block@0, item#1 <- block@4) +debug: Replaced trivial Phi node: let item#1: bytes = φ(item#0 <- block@0, item#1 <- block@4) (item#1) with item#0 in current definition for 3 blocks +debug: Added sequence#0 to Phi node: let sequence#1: bytes = φ(sequence#0 <- block@0) in block@0 +debug: Added sequence#1 to Phi node: let sequence#1: bytes = φ(sequence#0 <- block@0, sequence#1 <- block@4) in block@4 +debug: Replacing trivial Phi node: let sequence#1: bytes = φ(sequence#0 <- block@0, sequence#1 <- block@4) (sequence#1) with sequence#0 +debug: Deleting Phi assignment: let sequence#1: bytes = φ(sequence#0 <- block@0, sequence#1 <- block@4) +debug: Replaced trivial Phi node: let sequence#1: bytes = φ(sequence#0 <- block@0, sequence#1 <- block@4) (sequence#1) with sequence#0 in current definition for 3 blocks +debug: Sealing block@5 +debug: Terminated block@5 +debug: Building IR for function _puya_lib.arc4.dynamic_array_pop_bit +debug: Sealing block@0 +debug: Terminated block@0 +debug: Building IR for function _puya_lib.arc4.dynamic_array_pop_fixed_size +debug: Sealing block@0 +debug: Terminated block@0 +debug: Building IR for function _puya_lib.arc4.dynamic_array_pop_byte_length_head +debug: Sealing block@0 +debug: Terminated block@0 +debug: Building IR for function _puya_lib.arc4.dynamic_array_pop_dynamic_element +debug: Sealing block@0 +debug: Terminated block@0 +debug: Looking for 'value_internal%0' in an unsealed block creating an incomplete Phi: block@1 +debug: Created Phi assignment: let value_internal%0#1: uint64 = undefined while trying to resolve 'value_internal%0' in block@1 +debug: Terminated block@1 +debug: Sealing block@2 +debug: Looking for 'head_and_tail' in an unsealed block creating an incomplete Phi: block@1 +debug: Created Phi assignment: let head_and_tail#1: bytes = undefined while trying to resolve 'head_and_tail' in block@1 +debug: Looking for 'new_head' in an unsealed block creating an incomplete Phi: block@1 +debug: Created Phi assignment: let new_head#1: bytes = undefined while trying to resolve 'new_head' in block@1 +debug: Terminated block@2 +debug: Sealing block@3 +debug: Terminated block@3 +debug: Sealing block@1 +debug: Added value_internal%0#0 to Phi node: let value_internal%0#1: uint64 = φ(value_internal%0#0 <- block@0) in block@0 +debug: Added value_internal%0#2 to Phi node: let value_internal%0#1: uint64 = φ(value_internal%0#0 <- block@0, value_internal%0#2 <- block@3) in block@3 +debug: Added head_and_tail#0 to Phi node: let head_and_tail#1: bytes = φ(head_and_tail#0 <- block@0) in block@0 +debug: Added head_and_tail#1 to Phi node: let head_and_tail#1: bytes = φ(head_and_tail#0 <- block@0, head_and_tail#1 <- block@3) in block@3 +debug: Replacing trivial Phi node: let head_and_tail#1: bytes = φ(head_and_tail#0 <- block@0, head_and_tail#1 <- block@3) (head_and_tail#1) with head_and_tail#0 +debug: Deleting Phi assignment: let head_and_tail#1: bytes = φ(head_and_tail#0 <- block@0, head_and_tail#1 <- block@3) +debug: Replaced trivial Phi node: let head_and_tail#1: bytes = φ(head_and_tail#0 <- block@0, head_and_tail#1 <- block@3) (head_and_tail#1) with head_and_tail#0 in current definition for 3 blocks +debug: Added new_head#0 to Phi node: let new_head#1: bytes = φ(new_head#0 <- block@0) in block@0 +debug: Added new_head#2 to Phi node: let new_head#1: bytes = φ(new_head#0 <- block@0, new_head#2 <- block@3) in block@3 +debug: Sealing block@4 +debug: Created Phi assignment: let length_minus_1#1: uint64 = undefined while trying to resolve 'length_minus_1' in block@1 +debug: Added length_minus_1#0 to Phi node: let length_minus_1#1: uint64 = φ(length_minus_1#0 <- block@0) in block@0 +debug: Added length_minus_1#1 to Phi node: let length_minus_1#1: uint64 = φ(length_minus_1#0 <- block@0, length_minus_1#1 <- block@3) in block@3 +debug: Replacing trivial Phi node: let length_minus_1#1: uint64 = φ(length_minus_1#0 <- block@0, length_minus_1#1 <- block@3) (length_minus_1#1) with length_minus_1#0 +debug: Deleting Phi assignment: let length_minus_1#1: uint64 = φ(length_minus_1#0 <- block@0, length_minus_1#1 <- block@3) +debug: Replaced trivial Phi node: let length_minus_1#1: uint64 = φ(length_minus_1#0 <- block@0, length_minus_1#1 <- block@3) (length_minus_1#1) with length_minus_1#0 in current definition for 3 blocks +debug: Created Phi assignment: let popped_header_offset#1: uint64 = undefined while trying to resolve 'popped_header_offset' in block@1 +debug: Added popped_header_offset#0 to Phi node: let popped_header_offset#1: uint64 = φ(popped_header_offset#0 <- block@0) in block@0 +debug: Added popped_header_offset#1 to Phi node: let popped_header_offset#1: uint64 = φ(popped_header_offset#0 <- block@0, popped_header_offset#1 <- block@3) in block@3 +debug: Replacing trivial Phi node: let popped_header_offset#1: uint64 = φ(popped_header_offset#0 <- block@0, popped_header_offset#1 <- block@3) (popped_header_offset#1) with popped_header_offset#0 +debug: Deleting Phi assignment: let popped_header_offset#1: uint64 = φ(popped_header_offset#0 <- block@0, popped_header_offset#1 <- block@3) +debug: Replaced trivial Phi node: let popped_header_offset#1: uint64 = φ(popped_header_offset#0 <- block@0, popped_header_offset#1 <- block@3) (popped_header_offset#1) with popped_header_offset#0 in current definition for 3 blocks +debug: Created Phi assignment: let popped_offset#1: uint64 = undefined while trying to resolve 'popped_offset' in block@1 +debug: Added popped_offset#0 to Phi node: let popped_offset#1: uint64 = φ(popped_offset#0 <- block@0) in block@0 +debug: Added popped_offset#1 to Phi node: let popped_offset#1: uint64 = φ(popped_offset#0 <- block@0, popped_offset#1 <- block@3) in block@3 +debug: Replacing trivial Phi node: let popped_offset#1: uint64 = φ(popped_offset#0 <- block@0, popped_offset#1 <- block@3) (popped_offset#1) with popped_offset#0 +debug: Deleting Phi assignment: let popped_offset#1: uint64 = φ(popped_offset#0 <- block@0, popped_offset#1 <- block@3) +debug: Replaced trivial Phi node: let popped_offset#1: uint64 = φ(popped_offset#0 <- block@0, popped_offset#1 <- block@3) (popped_offset#1) with popped_offset#0 in current definition for 3 blocks +debug: Created Phi assignment: let popped#1: bytes = undefined while trying to resolve 'popped' in block@1 +debug: Added popped#0 to Phi node: let popped#1: bytes = φ(popped#0 <- block@0) in block@0 +debug: Added popped#1 to Phi node: let popped#1: bytes = φ(popped#0 <- block@0, popped#1 <- block@3) in block@3 +debug: Replacing trivial Phi node: let popped#1: bytes = φ(popped#0 <- block@0, popped#1 <- block@3) (popped#1) with popped#0 +debug: Deleting Phi assignment: let popped#1: bytes = φ(popped#0 <- block@0, popped#1 <- block@3) +debug: Replaced trivial Phi node: let popped#1: bytes = φ(popped#0 <- block@0, popped#1 <- block@3) (popped#1) with popped#0 in current definition for 3 blocks +debug: Terminated block@4 +debug: Building IR for function _puya_lib.arc4.dynamic_array_concat_bits +debug: Sealing block@0 +debug: Terminated block@0 +debug: Sealing block@1 +debug: Terminated block@1 +debug: Sealing block@2 +debug: Created Phi assignment: let array_length#1: uint64 = undefined while trying to resolve 'array_length' in block@2 +debug: Added array_length#0 to Phi node: let array_length#1: uint64 = φ(array_length#0 <- block@0) in block@0 +debug: Added array_length#0 to Phi node: let array_length#1: uint64 = φ(array_length#0 <- block@0, array_length#0 <- block@1) in block@1 +debug: Replacing trivial Phi node: let array_length#1: uint64 = φ(array_length#0 <- block@0, array_length#0 <- block@1) (array_length#1) with array_length#0 +debug: Deleting Phi assignment: let array_length#1: uint64 = φ(array_length#0 <- block@0, array_length#0 <- block@1) +debug: Replaced trivial Phi node: let array_length#1: uint64 = φ(array_length#0 <- block@0, array_length#0 <- block@1) (array_length#1) with array_length#0 in current definition for 1 blocks +debug: Created Phi assignment: let new_items_count#1: uint64 = undefined while trying to resolve 'new_items_count' in block@2 +debug: Added new_items_count#0 to Phi node: let new_items_count#1: uint64 = φ(new_items_count#0 <- block@0) in block@0 +debug: Added new_items_count#0 to Phi node: let new_items_count#1: uint64 = φ(new_items_count#0 <- block@0, new_items_count#0 <- block@1) in block@1 +debug: Replacing trivial Phi node: let new_items_count#1: uint64 = φ(new_items_count#0 <- block@0, new_items_count#0 <- block@1) (new_items_count#1) with new_items_count#0 +debug: Deleting Phi assignment: let new_items_count#1: uint64 = φ(new_items_count#0 <- block@0, new_items_count#0 <- block@1) +debug: Replaced trivial Phi node: let new_items_count#1: uint64 = φ(new_items_count#0 <- block@0, new_items_count#0 <- block@1) (new_items_count#1) with new_items_count#0 in current definition for 1 blocks +debug: Terminated block@2 +debug: Looking for 'write_offset' in an unsealed block creating an incomplete Phi: block@3 +debug: Created Phi assignment: let write_offset#1: uint64 = undefined while trying to resolve 'write_offset' in block@3 +debug: Looking for 'write_end' in an unsealed block creating an incomplete Phi: block@3 +debug: Created Phi assignment: let write_end#1: uint64 = undefined while trying to resolve 'write_end' in block@3 +debug: Terminated block@3 +debug: Sealing block@4 +debug: Looking for 'result' in an unsealed block creating an incomplete Phi: block@3 +debug: Created Phi assignment: let result#2: bytes = undefined while trying to resolve 'result' in block@3 +debug: Looking for 'new_items_bytes' in an unsealed block creating an incomplete Phi: block@3 +debug: Created Phi assignment: let new_items_bytes#1: bytes = undefined while trying to resolve 'new_items_bytes' in block@3 +debug: Looking for 'read_offset' in an unsealed block creating an incomplete Phi: block@3 +debug: Created Phi assignment: let read_offset#1: uint64 = undefined while trying to resolve 'read_offset' in block@3 +debug: Looking for 'read_step' in an unsealed block creating an incomplete Phi: block@3 +debug: Created Phi assignment: let read_step#1: uint64 = undefined while trying to resolve 'read_step' in block@3 +debug: Terminated block@4 +debug: Sealing block@3 +debug: Added write_offset#0 to Phi node: let write_offset#1: uint64 = φ(write_offset#0 <- block@2) in block@2 +debug: Added write_offset#2 to Phi node: let write_offset#1: uint64 = φ(write_offset#0 <- block@2, write_offset#2 <- block@4) in block@4 +debug: Added write_end#0 to Phi node: let write_end#1: uint64 = φ(write_end#0 <- block@2) in block@2 +debug: Added write_end#1 to Phi node: let write_end#1: uint64 = φ(write_end#0 <- block@2, write_end#1 <- block@4) in block@4 +debug: Replacing trivial Phi node: let write_end#1: uint64 = φ(write_end#0 <- block@2, write_end#1 <- block@4) (write_end#1) with write_end#0 +debug: Deleting Phi assignment: let write_end#1: uint64 = φ(write_end#0 <- block@2, write_end#1 <- block@4) +debug: Replaced trivial Phi node: let write_end#1: uint64 = φ(write_end#0 <- block@2, write_end#1 <- block@4) (write_end#1) with write_end#0 in current definition for 2 blocks +debug: Created Phi assignment: let result#4: bytes = undefined while trying to resolve 'result' in block@2 +debug: Added result#0 to Phi node: let result#4: bytes = φ(result#0 <- block@0) in block@0 +debug: Added result#1 to Phi node: let result#4: bytes = φ(result#0 <- block@0, result#1 <- block@1) in block@1 +debug: Added result#4 to Phi node: let result#2: bytes = φ(result#4 <- block@2) in block@2 +debug: Added result#3 to Phi node: let result#2: bytes = φ(result#4 <- block@2, result#3 <- block@4) in block@4 +debug: Created Phi assignment: let new_items_bytes#2: bytes = undefined while trying to resolve 'new_items_bytes' in block@2 +debug: Added new_items_bytes#0 to Phi node: let new_items_bytes#2: bytes = φ(new_items_bytes#0 <- block@0) in block@0 +debug: Added new_items_bytes#0 to Phi node: let new_items_bytes#2: bytes = φ(new_items_bytes#0 <- block@0, new_items_bytes#0 <- block@1) in block@1 +debug: Replacing trivial Phi node: let new_items_bytes#2: bytes = φ(new_items_bytes#0 <- block@0, new_items_bytes#0 <- block@1) (new_items_bytes#2) with new_items_bytes#0 +debug: Deleting Phi assignment: let new_items_bytes#2: bytes = φ(new_items_bytes#0 <- block@0, new_items_bytes#0 <- block@1) +debug: Replaced trivial Phi node: let new_items_bytes#2: bytes = φ(new_items_bytes#0 <- block@0, new_items_bytes#0 <- block@1) (new_items_bytes#2) with new_items_bytes#0 in current definition for 1 blocks +debug: Added new_items_bytes#0 to Phi node: let new_items_bytes#1: bytes = φ(new_items_bytes#0 <- block@2) in block@2 +debug: Added new_items_bytes#1 to Phi node: let new_items_bytes#1: bytes = φ(new_items_bytes#0 <- block@2, new_items_bytes#1 <- block@4) in block@4 +debug: Replacing trivial Phi node: let new_items_bytes#1: bytes = φ(new_items_bytes#0 <- block@2, new_items_bytes#1 <- block@4) (new_items_bytes#1) with new_items_bytes#0 +debug: Deleting Phi assignment: let new_items_bytes#1: bytes = φ(new_items_bytes#0 <- block@2, new_items_bytes#1 <- block@4) +debug: Replaced trivial Phi node: let new_items_bytes#1: bytes = φ(new_items_bytes#0 <- block@2, new_items_bytes#1 <- block@4) (new_items_bytes#1) with new_items_bytes#0 in current definition for 2 blocks +debug: Added read_offset#0 to Phi node: let read_offset#1: uint64 = φ(read_offset#0 <- block@2) in block@2 +debug: Added read_offset#2 to Phi node: let read_offset#1: uint64 = φ(read_offset#0 <- block@2, read_offset#2 <- block@4) in block@4 +debug: Created Phi assignment: let read_step#2: uint64 = undefined while trying to resolve 'read_step' in block@2 +debug: Added read_step#0 to Phi node: let read_step#2: uint64 = φ(read_step#0 <- block@0) in block@0 +debug: Added read_step#0 to Phi node: let read_step#2: uint64 = φ(read_step#0 <- block@0, read_step#0 <- block@1) in block@1 +debug: Replacing trivial Phi node: let read_step#2: uint64 = φ(read_step#0 <- block@0, read_step#0 <- block@1) (read_step#2) with read_step#0 +debug: Deleting Phi assignment: let read_step#2: uint64 = φ(read_step#0 <- block@0, read_step#0 <- block@1) +debug: Replaced trivial Phi node: let read_step#2: uint64 = φ(read_step#0 <- block@0, read_step#0 <- block@1) (read_step#2) with read_step#0 in current definition for 1 blocks +debug: Added read_step#0 to Phi node: let read_step#1: uint64 = φ(read_step#0 <- block@2) in block@2 +debug: Added read_step#1 to Phi node: let read_step#1: uint64 = φ(read_step#0 <- block@2, read_step#1 <- block@4) in block@4 +debug: Replacing trivial Phi node: let read_step#1: uint64 = φ(read_step#0 <- block@2, read_step#1 <- block@4) (read_step#1) with read_step#0 +debug: Deleting Phi assignment: let read_step#1: uint64 = φ(read_step#0 <- block@2, read_step#1 <- block@4) +debug: Replaced trivial Phi node: let read_step#1: uint64 = φ(read_step#0 <- block@2, read_step#1 <- block@4) (read_step#1) with read_step#0 in current definition for 2 blocks +debug: Sealing block@5 +debug: Terminated block@5 +debug: Building IR for function _puya_lib.arc4.dynamic_array_concat_byte_length_head +debug: Sealing block@0 +debug: Terminated block@0 +debug: Building IR for function _puya_lib.arc4.dynamic_array_concat_dynamic_element +debug: Sealing block@0 +debug: Terminated block@0 +debug: Looking for 'value_internal%0' in an unsealed block creating an incomplete Phi: block@1 +debug: Created Phi assignment: let value_internal%0#1: uint64 = undefined while trying to resolve 'value_internal%0' in block@1 +debug: Terminated block@1 +debug: Sealing block@2 +debug: Looking for 'array_head_and_tail' in an unsealed block creating an incomplete Phi: block@1 +debug: Created Phi assignment: let array_head_and_tail#1: bytes = undefined while trying to resolve 'array_head_and_tail' in block@1 +debug: Looking for 'new_head' in an unsealed block creating an incomplete Phi: block@1 +debug: Created Phi assignment: let new_head#1: bytes = undefined while trying to resolve 'new_head' in block@1 +debug: Looking for 'item_offset_adjustment' in an unsealed block creating an incomplete Phi: block@1 +debug: Created Phi assignment: let item_offset_adjustment#1: uint64 = undefined while trying to resolve 'item_offset_adjustment' in block@1 +debug: Terminated block@2 +debug: Sealing block@3 +debug: Terminated block@3 +debug: Sealing block@1 +debug: Added value_internal%0#0 to Phi node: let value_internal%0#1: uint64 = φ(value_internal%0#0 <- block@0) in block@0 +debug: Added value_internal%0#2 to Phi node: let value_internal%0#1: uint64 = φ(value_internal%0#0 <- block@0, value_internal%0#2 <- block@3) in block@3 +debug: Added array_head_and_tail#0 to Phi node: let array_head_and_tail#1: bytes = φ(array_head_and_tail#0 <- block@0) in block@0 +debug: Added array_head_and_tail#1 to Phi node: let array_head_and_tail#1: bytes = φ(array_head_and_tail#0 <- block@0, array_head_and_tail#1 <- block@3) in block@3 +debug: Replacing trivial Phi node: let array_head_and_tail#1: bytes = φ(array_head_and_tail#0 <- block@0, array_head_and_tail#1 <- block@3) (array_head_and_tail#1) with array_head_and_tail#0 +debug: Deleting Phi assignment: let array_head_and_tail#1: bytes = φ(array_head_and_tail#0 <- block@0, array_head_and_tail#1 <- block@3) +debug: Replaced trivial Phi node: let array_head_and_tail#1: bytes = φ(array_head_and_tail#0 <- block@0, array_head_and_tail#1 <- block@3) (array_head_and_tail#1) with array_head_and_tail#0 in current definition for 3 blocks +debug: Added new_head#0 to Phi node: let new_head#1: bytes = φ(new_head#0 <- block@0) in block@0 +debug: Added new_head#2 to Phi node: let new_head#1: bytes = φ(new_head#0 <- block@0, new_head#2 <- block@3) in block@3 +debug: Added item_offset_adjustment#0 to Phi node: let item_offset_adjustment#1: uint64 = φ(item_offset_adjustment#0 <- block@0) in block@0 +debug: Added item_offset_adjustment#1 to Phi node: let item_offset_adjustment#1: uint64 = φ(item_offset_adjustment#0 <- block@0, item_offset_adjustment#1 <- block@3) in block@3 +debug: Replacing trivial Phi node: let item_offset_adjustment#1: uint64 = φ(item_offset_adjustment#0 <- block@0, item_offset_adjustment#1 <- block@3) (item_offset_adjustment#1) with item_offset_adjustment#0 +debug: Deleting Phi assignment: let item_offset_adjustment#1: uint64 = φ(item_offset_adjustment#0 <- block@0, item_offset_adjustment#1 <- block@3) +debug: Replaced trivial Phi node: let item_offset_adjustment#1: uint64 = φ(item_offset_adjustment#0 <- block@0, item_offset_adjustment#1 <- block@3) (item_offset_adjustment#1) with item_offset_adjustment#0 in current definition for 3 blocks +debug: Sealing block@4 +debug: Created Phi assignment: let new_items_count#1: uint64 = undefined while trying to resolve 'new_items_count' in block@1 +debug: Added new_items_count#0 to Phi node: let new_items_count#1: uint64 = φ(new_items_count#0 <- block@0) in block@0 +debug: Added new_items_count#1 to Phi node: let new_items_count#1: uint64 = φ(new_items_count#0 <- block@0, new_items_count#1 <- block@3) in block@3 +debug: Replacing trivial Phi node: let new_items_count#1: uint64 = φ(new_items_count#0 <- block@0, new_items_count#1 <- block@3) (new_items_count#1) with new_items_count#0 +debug: Deleting Phi assignment: let new_items_count#1: uint64 = φ(new_items_count#0 <- block@0, new_items_count#1 <- block@3) +debug: Replaced trivial Phi node: let new_items_count#1: uint64 = φ(new_items_count#0 <- block@0, new_items_count#1 <- block@3) (new_items_count#1) with new_items_count#0 in current definition for 3 blocks +debug: Terminated block@4 +debug: Looking for 'value_internal%1' in an unsealed block creating an incomplete Phi: block@5 +debug: Created Phi assignment: let value_internal%1#1: uint64 = undefined while trying to resolve 'value_internal%1' in block@5 +debug: Terminated block@5 +debug: Sealing block@6 +debug: Looking for 'new_head_and_tail' in an unsealed block creating an incomplete Phi: block@5 +debug: Created Phi assignment: let new_head_and_tail#1: bytes = undefined while trying to resolve 'new_head_and_tail' in block@5 +debug: Looking for 'new_head' in an unsealed block creating an incomplete Phi: block@5 +debug: Created Phi assignment: let new_head#3: bytes = undefined while trying to resolve 'new_head' in block@5 +debug: Looking for 'head_and_tail_length' in an unsealed block creating an incomplete Phi: block@5 +debug: Created Phi assignment: let head_and_tail_length#1: uint64 = undefined while trying to resolve 'head_and_tail_length' in block@5 +debug: Terminated block@6 +debug: Sealing block@7 +debug: Terminated block@7 +debug: Sealing block@5 +debug: Added value_internal%1#0 to Phi node: let value_internal%1#1: uint64 = φ(value_internal%1#0 <- block@4) in block@4 +debug: Added value_internal%1#2 to Phi node: let value_internal%1#1: uint64 = φ(value_internal%1#0 <- block@4, value_internal%1#2 <- block@7) in block@7 +debug: Created Phi assignment: let new_head_and_tail#2: bytes = undefined while trying to resolve 'new_head_and_tail' in block@1 +debug: Added new_head_and_tail#0 to Phi node: let new_head_and_tail#2: bytes = φ(new_head_and_tail#0 <- block@0) in block@0 +debug: Added new_head_and_tail#2 to Phi node: let new_head_and_tail#2: bytes = φ(new_head_and_tail#0 <- block@0, new_head_and_tail#2 <- block@3) in block@3 +debug: Replacing trivial Phi node: let new_head_and_tail#2: bytes = φ(new_head_and_tail#0 <- block@0, new_head_and_tail#2 <- block@3) (new_head_and_tail#2) with new_head_and_tail#0 +debug: Deleting Phi assignment: let new_head_and_tail#2: bytes = φ(new_head_and_tail#0 <- block@0, new_head_and_tail#2 <- block@3) +debug: Replaced trivial Phi node: let new_head_and_tail#2: bytes = φ(new_head_and_tail#0 <- block@0, new_head_and_tail#2 <- block@3) (new_head_and_tail#2) with new_head_and_tail#0 in current definition for 3 blocks +debug: Added new_head_and_tail#0 to Phi node: let new_head_and_tail#1: bytes = φ(new_head_and_tail#0 <- block@4) in block@4 +debug: Added new_head_and_tail#1 to Phi node: let new_head_and_tail#1: bytes = φ(new_head_and_tail#0 <- block@4, new_head_and_tail#1 <- block@7) in block@7 +debug: Replacing trivial Phi node: let new_head_and_tail#1: bytes = φ(new_head_and_tail#0 <- block@4, new_head_and_tail#1 <- block@7) (new_head_and_tail#1) with new_head_and_tail#0 +debug: Deleting Phi assignment: let new_head_and_tail#1: bytes = φ(new_head_and_tail#0 <- block@4, new_head_and_tail#1 <- block@7) +debug: Replaced trivial Phi node: let new_head_and_tail#1: bytes = φ(new_head_and_tail#0 <- block@4, new_head_and_tail#1 <- block@7) (new_head_and_tail#1) with new_head_and_tail#0 in current definition for 3 blocks +debug: Added new_head#1 to Phi node: let new_head#3: bytes = φ(new_head#1 <- block@4) in block@4 +debug: Added new_head#4 to Phi node: let new_head#3: bytes = φ(new_head#1 <- block@4, new_head#4 <- block@7) in block@7 +debug: Added head_and_tail_length#0 to Phi node: let head_and_tail_length#1: uint64 = φ(head_and_tail_length#0 <- block@4) in block@4 +debug: Added head_and_tail_length#1 to Phi node: let head_and_tail_length#1: uint64 = φ(head_and_tail_length#0 <- block@4, head_and_tail_length#1 <- block@7) in block@7 +debug: Replacing trivial Phi node: let head_and_tail_length#1: uint64 = φ(head_and_tail_length#0 <- block@4, head_and_tail_length#1 <- block@7) (head_and_tail_length#1) with head_and_tail_length#0 +debug: Deleting Phi assignment: let head_and_tail_length#1: uint64 = φ(head_and_tail_length#0 <- block@4, head_and_tail_length#1 <- block@7) +debug: Replaced trivial Phi node: let head_and_tail_length#1: uint64 = φ(head_and_tail_length#0 <- block@4, head_and_tail_length#1 <- block@7) (head_and_tail_length#1) with head_and_tail_length#0 in current definition for 3 blocks +debug: Sealing block@8 +debug: Created Phi assignment: let array_items_count#1: uint64 = undefined while trying to resolve 'array_items_count' in block@5 +debug: Created Phi assignment: let array_items_count#2: uint64 = undefined while trying to resolve 'array_items_count' in block@1 +debug: Added array_items_count#0 to Phi node: let array_items_count#2: uint64 = φ(array_items_count#0 <- block@0) in block@0 +debug: Added array_items_count#2 to Phi node: let array_items_count#2: uint64 = φ(array_items_count#0 <- block@0, array_items_count#2 <- block@3) in block@3 +debug: Replacing trivial Phi node: let array_items_count#2: uint64 = φ(array_items_count#0 <- block@0, array_items_count#2 <- block@3) (array_items_count#2) with array_items_count#0 +debug: Deleting Phi assignment: let array_items_count#2: uint64 = φ(array_items_count#0 <- block@0, array_items_count#2 <- block@3) +debug: Replaced trivial Phi node: let array_items_count#2: uint64 = φ(array_items_count#0 <- block@0, array_items_count#2 <- block@3) (array_items_count#2) with array_items_count#0 in current definition for 3 blocks +debug: Added array_items_count#0 to Phi node: let array_items_count#1: uint64 = φ(array_items_count#0 <- block@4) in block@4 +debug: Added array_items_count#1 to Phi node: let array_items_count#1: uint64 = φ(array_items_count#0 <- block@4, array_items_count#1 <- block@7) in block@7 +debug: Replacing trivial Phi node: let array_items_count#1: uint64 = φ(array_items_count#0 <- block@4, array_items_count#1 <- block@7) (array_items_count#1) with array_items_count#0 +debug: Deleting Phi assignment: let array_items_count#1: uint64 = φ(array_items_count#0 <- block@4, array_items_count#1 <- block@7) +debug: Replaced trivial Phi node: let array_items_count#1: uint64 = φ(array_items_count#0 <- block@4, array_items_count#1 <- block@7) (array_items_count#1) with array_items_count#0 in current definition for 3 blocks +debug: Created Phi assignment: let new_items_count#2: uint64 = undefined while trying to resolve 'new_items_count' in block@5 +debug: Added new_items_count#0 to Phi node: let new_items_count#2: uint64 = φ(new_items_count#0 <- block@4) in block@4 +debug: Added new_items_count#2 to Phi node: let new_items_count#2: uint64 = φ(new_items_count#0 <- block@4, new_items_count#2 <- block@7) in block@7 +debug: Replacing trivial Phi node: let new_items_count#2: uint64 = φ(new_items_count#0 <- block@4, new_items_count#2 <- block@7) (new_items_count#2) with new_items_count#0 +debug: Deleting Phi assignment: let new_items_count#2: uint64 = φ(new_items_count#0 <- block@4, new_items_count#2 <- block@7) +debug: Replaced trivial Phi node: let new_items_count#2: uint64 = φ(new_items_count#0 <- block@4, new_items_count#2 <- block@7) (new_items_count#2) with new_items_count#0 in current definition for 3 blocks +debug: Created Phi assignment: let array_head_and_tail#2: bytes = undefined while trying to resolve 'array_head_and_tail' in block@5 +debug: Added array_head_and_tail#0 to Phi node: let array_head_and_tail#2: bytes = φ(array_head_and_tail#0 <- block@4) in block@4 +debug: Added array_head_and_tail#2 to Phi node: let array_head_and_tail#2: bytes = φ(array_head_and_tail#0 <- block@4, array_head_and_tail#2 <- block@7) in block@7 +debug: Replacing trivial Phi node: let array_head_and_tail#2: bytes = φ(array_head_and_tail#0 <- block@4, array_head_and_tail#2 <- block@7) (array_head_and_tail#2) with array_head_and_tail#0 +debug: Deleting Phi assignment: let array_head_and_tail#2: bytes = φ(array_head_and_tail#0 <- block@4, array_head_and_tail#2 <- block@7) +debug: Replaced trivial Phi node: let array_head_and_tail#2: bytes = φ(array_head_and_tail#0 <- block@4, array_head_and_tail#2 <- block@7) (array_head_and_tail#2) with array_head_and_tail#0 in current definition for 3 blocks +debug: Terminated block@8 +debug: Building IR for function _puya_lib.arc4.dynamic_array_replace_byte_length_head +debug: Sealing block@0 +debug: Terminated block@0 +debug: Building IR for function _puya_lib.arc4.dynamic_array_replace_dynamic_element +debug: Sealing block@0 +debug: Terminated block@0 +debug: Building IR for function _puya_lib.arc4.static_array_replace_dynamic_element +debug: Sealing block@0 +debug: Terminated block@0 +debug: Looking for 'value_internal%0' in an unsealed block creating an incomplete Phi: block@1 +debug: Created Phi assignment: let value_internal%0#1: uint64 = undefined while trying to resolve 'value_internal%0' in block@1 +debug: Terminated block@1 +debug: Sealing block@2 +debug: Looking for 'new_head_and_tail' in an unsealed block creating an incomplete Phi: block@1 +debug: Created Phi assignment: let new_head_and_tail#1: bytes = undefined while trying to resolve 'new_head_and_tail' in block@1 +debug: Looking for 'new_item_length' in an unsealed block creating an incomplete Phi: block@1 +debug: Created Phi assignment: let new_item_length#1: uint64 = undefined while trying to resolve 'new_item_length' in block@1 +debug: Looking for 'original_item_length' in an unsealed block creating an incomplete Phi: block@1 +debug: Created Phi assignment: let original_item_length#1: uint64 = undefined while trying to resolve 'original_item_length' in block@1 +debug: Terminated block@2 +debug: Sealing block@3 +debug: Terminated block@3 +debug: Sealing block@1 +debug: Added value_internal%0#0 to Phi node: let value_internal%0#1: uint64 = φ(value_internal%0#0 <- block@0) in block@0 +debug: Added value_internal%0#2 to Phi node: let value_internal%0#1: uint64 = φ(value_internal%0#0 <- block@0, value_internal%0#2 <- block@3) in block@3 +debug: Added new_head_and_tail#0 to Phi node: let new_head_and_tail#1: bytes = φ(new_head_and_tail#0 <- block@0) in block@0 +debug: Added new_head_and_tail#2 to Phi node: let new_head_and_tail#1: bytes = φ(new_head_and_tail#0 <- block@0, new_head_and_tail#2 <- block@3) in block@3 +debug: Added new_item_length#0 to Phi node: let new_item_length#1: uint64 = φ(new_item_length#0 <- block@0) in block@0 +debug: Added new_item_length#1 to Phi node: let new_item_length#1: uint64 = φ(new_item_length#0 <- block@0, new_item_length#1 <- block@3) in block@3 +debug: Replacing trivial Phi node: let new_item_length#1: uint64 = φ(new_item_length#0 <- block@0, new_item_length#1 <- block@3) (new_item_length#1) with new_item_length#0 +debug: Deleting Phi assignment: let new_item_length#1: uint64 = φ(new_item_length#0 <- block@0, new_item_length#1 <- block@3) +debug: Replaced trivial Phi node: let new_item_length#1: uint64 = φ(new_item_length#0 <- block@0, new_item_length#1 <- block@3) (new_item_length#1) with new_item_length#0 in current definition for 3 blocks +debug: Added original_item_length#0 to Phi node: let original_item_length#1: uint64 = φ(original_item_length#0 <- block@0) in block@0 +debug: Added original_item_length#1 to Phi node: let original_item_length#1: uint64 = φ(original_item_length#0 <- block@0, original_item_length#1 <- block@3) in block@3 +debug: Replacing trivial Phi node: let original_item_length#1: uint64 = φ(original_item_length#0 <- block@0, original_item_length#1 <- block@3) (original_item_length#1) with original_item_length#0 +debug: Deleting Phi assignment: let original_item_length#1: uint64 = φ(original_item_length#0 <- block@0, original_item_length#1 <- block@3) +debug: Replaced trivial Phi node: let original_item_length#1: uint64 = φ(original_item_length#0 <- block@0, original_item_length#1 <- block@3) (original_item_length#1) with original_item_length#0 in current definition for 3 blocks +debug: Sealing block@4 +debug: Terminated block@4 +debug: Building IR for function _puya_lib.arc4.static_array_replace_byte_length_head +debug: Sealing block@0 +debug: Terminated block@0 +debug: Building IR for function _puya_lib.arc4.recalculate_head_for_elements_with_byte_length_head +debug: Sealing block@0 +debug: Terminated block@0 +debug: Looking for 'value_internal%0' in an unsealed block creating an incomplete Phi: block@1 +debug: Created Phi assignment: let value_internal%0#1: uint64 = undefined while trying to resolve 'value_internal%0' in block@1 +debug: Terminated block@1 +debug: Sealing block@2 +debug: Looking for 'tail_offset' in an unsealed block creating an incomplete Phi: block@1 +debug: Created Phi assignment: let tail_offset#1: uint64 = undefined while trying to resolve 'tail_offset' in block@1 +debug: Looking for 'array_head_and_tail' in an unsealed block creating an incomplete Phi: block@1 +debug: Created Phi assignment: let array_head_and_tail#1: bytes = undefined while trying to resolve 'array_head_and_tail' in block@1 +debug: Terminated block@2 +debug: Sealing block@3 +debug: Terminated block@3 +debug: Sealing block@1 +debug: Added value_internal%0#0 to Phi node: let value_internal%0#1: uint64 = φ(value_internal%0#0 <- block@0) in block@0 +debug: Added value_internal%0#2 to Phi node: let value_internal%0#1: uint64 = φ(value_internal%0#0 <- block@0, value_internal%0#2 <- block@3) in block@3 +debug: Added tail_offset#0 to Phi node: let tail_offset#1: uint64 = φ(tail_offset#0 <- block@0) in block@0 +debug: Added tail_offset#2 to Phi node: let tail_offset#1: uint64 = φ(tail_offset#0 <- block@0, tail_offset#2 <- block@3) in block@3 +debug: Added array_head_and_tail#0 to Phi node: let array_head_and_tail#1: bytes = φ(array_head_and_tail#0 <- block@0) in block@0 +debug: Added array_head_and_tail#2 to Phi node: let array_head_and_tail#1: bytes = φ(array_head_and_tail#0 <- block@0, array_head_and_tail#2 <- block@3) in block@3 +debug: Sealing block@4 +debug: Terminated block@4 +debug: Building IR for function test_cases.structure_methods.contract.ARC4TestStruct.return_value_times +debug: Sealing block@0 +debug: Terminated block@0 +debug: Building IR for function test_cases.structure_methods.contract.ARC4TestStruct.return1 +debug: Sealing block@0 +debug: Terminated block@0 +debug: Building IR for function test_cases.structure_methods.contract.TestStruct.return_value_times +debug: Sealing block@0 +debug: Terminated block@0 +debug: Building IR for function test_cases.structure_methods.contract.TestStruct.return1 +debug: Sealing block@0 +debug: Terminated block@0 +debug: Building IR for function test_cases.structure_methods.contract.TestNamedTuple.return_value_times +debug: Sealing block@0 +debug: Terminated block@0 +debug: Building IR for function test_cases.structure_methods.contract.TestNamedTuple.return1 +debug: Sealing block@0 +debug: Terminated block@0 +debug: Building IR for function test_cases.structure_methods.contract.GroupedMethods.never_inlined_usually_inlined +debug: Sealing block@0 +debug: Terminated block@0 +debug: Building IR for function test_cases.structure_methods.contract.GroupedMethods.always_inlined_not_usually_inlined +debug: Sealing block@0 +debug: Terminated block@0 +debug: Building IR for function test_cases.structure_methods.contract.GroupedMethods.usually_inlined +debug: Sealing block@0 +debug: Terminated block@0 +debug: Building IR for function test_cases.structure_methods.contract.GroupedMethods.not_usually_inlined +debug: Sealing block@0 +debug: Terminated block@0 +debug: Building IR for function test_cases.structure_methods.contract.TestContract.__puya_arc4_router__ +debug: Sealing block@0 +debug: Terminated block@0 +debug: Sealing block@1 +debug: Terminated block@1 +debug: Sealing block@2 +debug: Terminated block@2 +debug: Sealing block@3 +debug: Terminated block@3 +debug: Sealing block@4 +debug: Terminated block@4 +debug: Sealing block@5 +debug: Terminated block@5 +debug: Building IR for function test_cases.structure_methods.contract.TestContract.test[routing] +debug: Sealing block@0 +debug: Terminated block@0 +debug: Building IR for function test_cases.structure_methods.contract.TestContract.test +debug: Sealing block@0 +debug: Terminated block@0 +debug: Building IR for function test_cases.structure_methods.contract.TestContract.__algopy_default_create +debug: Sealing block@0 +debug: Terminated block@0 +debug: Building IR for function algopy.arc4.ARC4Contract.approval_program +debug: Sealing block@0 +debug: Terminated block@0 +debug: Building IR for function algopy.arc4.ARC4Contract.clear_state_program +debug: Sealing block@0 +debug: Terminated block@0 +debug: Building IR for function algopy._contract.Contract.__init__ +debug: Sealing block@0 +debug: Terminated block@0 +debug: Building IR for function algopy.arc4.ARC4Contract.approval_program +debug: Sealing block@0 +debug: Terminated block@0 +debug: removing unused subroutine _puya_lib.util.ensure_budget +debug: removing unused subroutine _puya_lib.bytes_.is_substring +debug: removing unused subroutine _puya_lib.arc4.dynamic_array_pop_bit +debug: removing unused subroutine _puya_lib.arc4.dynamic_array_pop_fixed_size +debug: removing unused subroutine _puya_lib.arc4.dynamic_array_pop_byte_length_head +debug: removing unused subroutine _puya_lib.arc4.dynamic_array_pop_dynamic_element +debug: removing unused subroutine _puya_lib.arc4.dynamic_array_concat_bits +debug: removing unused subroutine _puya_lib.arc4.dynamic_array_concat_byte_length_head +debug: removing unused subroutine _puya_lib.arc4.dynamic_array_concat_dynamic_element +debug: removing unused subroutine _puya_lib.arc4.dynamic_array_replace_byte_length_head +debug: removing unused subroutine _puya_lib.arc4.dynamic_array_replace_dynamic_element +debug: removing unused subroutine _puya_lib.arc4.static_array_replace_dynamic_element +debug: removing unused subroutine _puya_lib.arc4.static_array_replace_byte_length_head +debug: removing unused subroutine _puya_lib.arc4.recalculate_head_for_elements_with_byte_length_head +debug: removing unused subroutine algopy.arc4.ARC4Contract.approval_program +debug: removing unused subroutine algopy.arc4.ARC4Contract.clear_state_program +debug: removing unused subroutine algopy._contract.Contract.__init__ +debug: Building IR for function algopy.arc4.ARC4Contract.clear_state_program +debug: Sealing block@0 +debug: Terminated block@0 +debug: removing unused subroutine _puya_lib.util.ensure_budget +debug: removing unused subroutine _puya_lib.bytes_.is_substring +debug: removing unused subroutine _puya_lib.arc4.dynamic_array_pop_bit +debug: removing unused subroutine _puya_lib.arc4.dynamic_array_pop_fixed_size +debug: removing unused subroutine _puya_lib.arc4.dynamic_array_pop_byte_length_head +debug: removing unused subroutine _puya_lib.arc4.dynamic_array_pop_dynamic_element +debug: removing unused subroutine _puya_lib.arc4.dynamic_array_concat_bits +debug: removing unused subroutine _puya_lib.arc4.dynamic_array_concat_byte_length_head +debug: removing unused subroutine _puya_lib.arc4.dynamic_array_concat_dynamic_element +debug: removing unused subroutine _puya_lib.arc4.dynamic_array_replace_byte_length_head +debug: removing unused subroutine _puya_lib.arc4.dynamic_array_replace_dynamic_element +debug: removing unused subroutine _puya_lib.arc4.static_array_replace_dynamic_element +debug: removing unused subroutine _puya_lib.arc4.static_array_replace_byte_length_head +debug: removing unused subroutine _puya_lib.arc4.recalculate_head_for_elements_with_byte_length_head +debug: removing unused subroutine test_cases.structure_methods.contract.ARC4TestStruct.return_value_times +debug: removing unused subroutine test_cases.structure_methods.contract.ARC4TestStruct.return1 +debug: removing unused subroutine test_cases.structure_methods.contract.TestStruct.return_value_times +debug: removing unused subroutine test_cases.structure_methods.contract.TestStruct.return1 +debug: removing unused subroutine test_cases.structure_methods.contract.TestNamedTuple.return_value_times +debug: removing unused subroutine test_cases.structure_methods.contract.TestNamedTuple.return1 +debug: removing unused subroutine test_cases.structure_methods.contract.GroupedMethods.never_inlined_usually_inlined +debug: removing unused subroutine test_cases.structure_methods.contract.GroupedMethods.always_inlined_not_usually_inlined +debug: removing unused subroutine test_cases.structure_methods.contract.GroupedMethods.usually_inlined +debug: removing unused subroutine test_cases.structure_methods.contract.GroupedMethods.not_usually_inlined +debug: removing unused subroutine test_cases.structure_methods.contract.TestContract.__puya_arc4_router__ +debug: removing unused subroutine test_cases.structure_methods.contract.TestContract.test[routing] +debug: removing unused subroutine test_cases.structure_methods.contract.TestContract.test +debug: removing unused subroutine test_cases.structure_methods.contract.TestContract.__algopy_default_create +debug: removing unused subroutine algopy.arc4.ARC4Contract.approval_program +debug: removing unused subroutine algopy.arc4.ARC4Contract.clear_state_program +debug: removing unused subroutine algopy._contract.Contract.__init__ +debug: optimizing approval program of test_cases.structure_methods.contract.TestContract at level 2 +debug: Begin optimization pass 1/100 +debug: marking trivial method test_cases.structure_methods.contract.ARC4TestStruct.return1 as inlineable +debug: marking trivial method test_cases.structure_methods.contract.TestStruct.return1 as inlineable +debug: marking trivial method test_cases.structure_methods.contract.TestNamedTuple.return1 as inlineable +debug: marking single-use function test_cases.structure_methods.contract.TestContract.test[routing] for inlining +debug: marking single-use function test_cases.structure_methods.contract.TestContract.test for inlining +debug: Optimizing subroutine algopy.arc4.ARC4Contract.approval_program +debug: Optimizer: Perform Subroutine Inlining +debug: inlining call to test_cases.structure_methods.contract.TestContract.__puya_arc4_router__ in algopy.arc4.ARC4Contract.approval_program +debug: Optimizer: Split Parallel Copies +debug: Optimizer: Constant Replacer +debug: Optimizer: Copy Propagation +debug: Optimizer: Elide Itxn Field Calls +debug: Optimizer: Remove Unused Variables +debug: Optimizer: Intrinsic Simplifier +debug: Simplified (== tmp%3#0 NoOp) to (! tmp%3#0) +debug: Simplified (&& tmp%4#0 tmp%6#0) to (&& tmp%4#0 tmp%5#0) +debug: Simplified (== tmp%8#0 NoOp) to (! tmp%8#0) +debug: Simplified (== tmp%10#0 0u) to (! tmp%10#0) +debug: Optimizer: Inner Txn Field Replacer +debug: Optimizer: Replace Compiled References +debug: Optimizer: Simplify Control Ops +debug: simplifying exit 0 to err +debug: simplified terminator of block@6 from exit 0u to fail +debug: Optimizer: Merge Blocks +debug: Replaced predecessor block@1 with block@0 in block@5 +debug: Replaced predecessor block@1 with block@0 in block@2 +debug: Merged linear block@1 into block@0 +debug: Merged linear block@6 into block@4 +debug: Optimizer: Remove Linear Jumps +debug: Optimizer: Remove Unreachable Blocks +debug: Removing unreachable block: block@7 +debug: Optimizer: Repeated Expression Elimination +debug: Optimizer: Encode Decode Pair Elimination +debug: Optimizer: Merge Chained Aggregate Reads +debug: Optimizer: Replace Aggregate Box Ops +debug: Optimizer: Minimize Box Exist Asserts +debug: Optimizer: Constant Reads And Unobserved Writes Elimination +debug: Optimizing subroutine test_cases.structure_methods.contract.ARC4TestStruct.return_value_times +debug: Optimizer: Perform Subroutine Inlining +debug: Optimizer: Split Parallel Copies +debug: Optimizer: Constant Replacer +debug: Optimizer: Copy Propagation +debug: Found equivalence set: self#0, self%out#0 +debug: selected self#0 from equivalence set +debug: Optimizer: Elide Itxn Field Calls +debug: Optimizer: Remove Unused Variables +debug: Removing unused variable self%is_original#0 +debug: Optimizer: Intrinsic Simplifier +debug: Optimizer: Inner Txn Field Replacer +debug: Optimizer: Replace Compiled References +debug: Optimizer: Simplify Control Ops +debug: Optimizer: Merge Blocks +debug: Optimizer: Remove Linear Jumps +debug: Optimizer: Remove Unreachable Blocks +debug: Optimizer: Repeated Expression Elimination +debug: Optimizer: Encode Decode Pair Elimination +debug: Optimizer: Merge Chained Aggregate Reads +debug: Optimizer: Replace Aggregate Box Ops +debug: Optimizer: Minimize Box Exist Asserts +debug: Optimizer: Constant Reads And Unobserved Writes Elimination +debug: Optimizing subroutine test_cases.structure_methods.contract.ARC4TestStruct.return1 +debug: Optimizer: Perform Subroutine Inlining +debug: Optimizer: Split Parallel Copies +debug: Optimizer: Constant Replacer +debug: Optimizer: Copy Propagation +debug: Optimizer: Elide Itxn Field Calls +debug: Optimizer: Remove Unused Variables +debug: Optimizer: Intrinsic Simplifier +debug: Optimizer: Inner Txn Field Replacer +debug: Optimizer: Replace Compiled References +debug: Optimizer: Simplify Control Ops +debug: Optimizer: Merge Blocks +debug: Optimizer: Remove Linear Jumps +debug: Optimizer: Remove Unreachable Blocks +debug: Optimizer: Repeated Expression Elimination +debug: Optimizer: Encode Decode Pair Elimination +debug: Optimizer: Merge Chained Aggregate Reads +debug: Optimizer: Replace Aggregate Box Ops +debug: Optimizer: Minimize Box Exist Asserts +debug: Optimizer: Constant Reads And Unobserved Writes Elimination +debug: Optimizing subroutine test_cases.structure_methods.contract.TestStruct.return_value_times +debug: Optimizer: Perform Subroutine Inlining +debug: Optimizer: Split Parallel Copies +debug: Optimizer: Constant Replacer +debug: Optimizer: Copy Propagation +debug: Found equivalence set: self#0, self%out#0 +debug: selected self#0 from equivalence set +debug: Optimizer: Elide Itxn Field Calls +debug: Optimizer: Remove Unused Variables +debug: Removing unused variable self%is_original#0 +debug: Optimizer: Intrinsic Simplifier +debug: Optimizer: Inner Txn Field Replacer +debug: Optimizer: Replace Compiled References +debug: Optimizer: Simplify Control Ops +debug: Optimizer: Merge Blocks +debug: Optimizer: Remove Linear Jumps +debug: Optimizer: Remove Unreachable Blocks +debug: Optimizer: Repeated Expression Elimination +debug: Optimizer: Encode Decode Pair Elimination +debug: Optimizer: Merge Chained Aggregate Reads +debug: Optimizer: Replace Aggregate Box Ops +debug: Optimizer: Minimize Box Exist Asserts +debug: Optimizer: Constant Reads And Unobserved Writes Elimination +debug: Optimizing subroutine test_cases.structure_methods.contract.TestStruct.return1 +debug: Optimizer: Perform Subroutine Inlining +debug: Optimizer: Split Parallel Copies +debug: Optimizer: Constant Replacer +debug: Optimizer: Copy Propagation +debug: Optimizer: Elide Itxn Field Calls +debug: Optimizer: Remove Unused Variables +debug: Optimizer: Intrinsic Simplifier +debug: Optimizer: Inner Txn Field Replacer +debug: Optimizer: Replace Compiled References +debug: Optimizer: Simplify Control Ops +debug: Optimizer: Merge Blocks +debug: Optimizer: Remove Linear Jumps +debug: Optimizer: Remove Unreachable Blocks +debug: Optimizer: Repeated Expression Elimination +debug: Optimizer: Encode Decode Pair Elimination +debug: Optimizer: Merge Chained Aggregate Reads +debug: Optimizer: Replace Aggregate Box Ops +debug: Optimizer: Minimize Box Exist Asserts +debug: Optimizer: Constant Reads And Unobserved Writes Elimination +debug: Optimizing subroutine test_cases.structure_methods.contract.TestNamedTuple.return_value_times +debug: Optimizer: Perform Subroutine Inlining +debug: Optimizer: Split Parallel Copies +debug: Optimizer: Constant Replacer +debug: Optimizer: Copy Propagation +debug: Optimizer: Elide Itxn Field Calls +debug: Optimizer: Remove Unused Variables +debug: Optimizer: Intrinsic Simplifier +debug: Optimizer: Inner Txn Field Replacer +debug: Optimizer: Replace Compiled References +debug: Optimizer: Simplify Control Ops +debug: Optimizer: Merge Blocks +debug: Optimizer: Remove Linear Jumps +debug: Optimizer: Remove Unreachable Blocks +debug: Optimizer: Repeated Expression Elimination +debug: Optimizer: Encode Decode Pair Elimination +debug: Optimizer: Merge Chained Aggregate Reads +debug: Optimizer: Replace Aggregate Box Ops +debug: Optimizer: Minimize Box Exist Asserts +debug: Optimizer: Constant Reads And Unobserved Writes Elimination +debug: Optimizing subroutine test_cases.structure_methods.contract.TestNamedTuple.return1 +debug: Optimizer: Perform Subroutine Inlining +debug: Optimizer: Split Parallel Copies +debug: Optimizer: Constant Replacer +debug: Optimizer: Copy Propagation +debug: Optimizer: Elide Itxn Field Calls +debug: Optimizer: Remove Unused Variables +debug: Optimizer: Intrinsic Simplifier +debug: Optimizer: Inner Txn Field Replacer +debug: Optimizer: Replace Compiled References +debug: Optimizer: Simplify Control Ops +debug: Optimizer: Merge Blocks +debug: Optimizer: Remove Linear Jumps +debug: Optimizer: Remove Unreachable Blocks +debug: Optimizer: Repeated Expression Elimination +debug: Optimizer: Encode Decode Pair Elimination +debug: Optimizer: Merge Chained Aggregate Reads +debug: Optimizer: Replace Aggregate Box Ops +debug: Optimizer: Minimize Box Exist Asserts +debug: Optimizer: Constant Reads And Unobserved Writes Elimination +debug: Optimizing subroutine test_cases.structure_methods.contract.GroupedMethods.never_inlined_usually_inlined +debug: Optimizer: Perform Subroutine Inlining +debug: Optimizer: Split Parallel Copies +debug: Optimizer: Constant Replacer +debug: Optimizer: Copy Propagation +debug: Optimizer: Elide Itxn Field Calls +debug: Optimizer: Remove Unused Variables +debug: Optimizer: Intrinsic Simplifier +debug: Optimizer: Inner Txn Field Replacer +debug: Optimizer: Replace Compiled References +debug: Optimizer: Simplify Control Ops +debug: Optimizer: Merge Blocks +debug: Optimizer: Remove Linear Jumps +debug: Optimizer: Remove Unreachable Blocks +debug: Optimizer: Repeated Expression Elimination +debug: Optimizer: Encode Decode Pair Elimination +debug: Optimizer: Merge Chained Aggregate Reads +debug: Optimizer: Replace Aggregate Box Ops +debug: Optimizer: Minimize Box Exist Asserts +debug: Optimizer: Constant Reads And Unobserved Writes Elimination +debug: Optimizing subroutine test_cases.structure_methods.contract.GroupedMethods.always_inlined_not_usually_inlined +debug: Optimizer: Perform Subroutine Inlining +debug: Optimizer: Split Parallel Copies +debug: Optimizer: Constant Replacer +debug: Optimizer: Copy Propagation +debug: Optimizer: Elide Itxn Field Calls +debug: Optimizer: Remove Unused Variables +debug: Optimizer: Intrinsic Simplifier +debug: Optimizer: Inner Txn Field Replacer +debug: Optimizer: Replace Compiled References +debug: Optimizer: Simplify Control Ops +debug: Optimizer: Merge Blocks +debug: Optimizer: Remove Linear Jumps +debug: Optimizer: Remove Unreachable Blocks +debug: Optimizer: Repeated Expression Elimination +debug: Replacing redundant declaration let tmp%2#0: Encoded(uint64) = bytes_encode(v#0) with copy of existing registers [Register(source_location=structure_methods/contract.py:46:33-47, ir_type=Encoded(uint64), name='tmp%0', version=0)] +debug: Replacing redundant declaration let tmp%4#0: Encoded(uint64) = bytes_encode(v#0) with copy of existing registers [Register(source_location=structure_methods/contract.py:46:33-47, ir_type=Encoded(uint64), name='tmp%0', version=0)] +debug: Replacing redundant declaration let tmp%6#0: Encoded(uint64) = bytes_encode(v#0) with copy of existing registers [Register(source_location=structure_methods/contract.py:46:33-47, ir_type=Encoded(uint64), name='tmp%0', version=0)] +debug: Replacing redundant declaration let tmp%8#0: Encoded(uint64) = bytes_encode(v#0) with copy of existing registers [Register(source_location=structure_methods/contract.py:46:33-47, ir_type=Encoded(uint64), name='tmp%0', version=0)] +debug: Replacing redundant declaration let tmp%10#0: Encoded(uint64) = bytes_encode(v#0) with copy of existing registers [Register(source_location=structure_methods/contract.py:46:33-47, ir_type=Encoded(uint64), name='tmp%0', version=0)] +debug: Replacing redundant declaration let tmp%12#0: Encoded(uint64) = bytes_encode(v#0) with copy of existing registers [Register(source_location=structure_methods/contract.py:46:33-47, ir_type=Encoded(uint64), name='tmp%0', version=0)] +debug: Replacing redundant declaration let tmp%14#0: Encoded(uint64) = bytes_encode(v#0) with copy of existing registers [Register(source_location=structure_methods/contract.py:46:33-47, ir_type=Encoded(uint64), name='tmp%0', version=0)] +debug: Found equivalence set: tmp%0#0, tmp%2#0, tmp%4#0, tmp%6#0, tmp%8#0, tmp%10#0, tmp%12#0, tmp%14#0 +debug: selected tmp%0#0 from equivalence set +debug: Copy propagation made 7 modifications +debug: Replacing redundant declaration let tmp%3#0: Encoded(uint64) = bytes_encode<(uint64)>(tmp%0#0) with copy of existing registers [Register(source_location=structure_methods/contract.py:46:18-48, ir_type=Encoded(uint64), name='tmp%1', version=0)] +debug: Replacing redundant declaration let tmp%5#0: Encoded(uint64) = bytes_encode<(uint64)>(tmp%0#0) with copy of existing registers [Register(source_location=structure_methods/contract.py:46:18-48, ir_type=Encoded(uint64), name='tmp%1', version=0)] +debug: Replacing redundant declaration let tmp%7#0: Encoded(uint64) = bytes_encode<(uint64)>(tmp%0#0) with copy of existing registers [Register(source_location=structure_methods/contract.py:46:18-48, ir_type=Encoded(uint64), name='tmp%1', version=0)] +debug: Replacing redundant declaration let tmp%9#0: Encoded(uint64) = bytes_encode<(uint64)>(tmp%0#0) with copy of existing registers [Register(source_location=structure_methods/contract.py:46:18-48, ir_type=Encoded(uint64), name='tmp%1', version=0)] +debug: Replacing redundant declaration let tmp%11#0: Encoded(uint64) = bytes_encode<(uint64)>(tmp%0#0) with copy of existing registers [Register(source_location=structure_methods/contract.py:46:18-48, ir_type=Encoded(uint64), name='tmp%1', version=0)] +debug: Replacing redundant declaration let tmp%13#0: Encoded(uint64) = bytes_encode<(uint64)>(tmp%0#0) with copy of existing registers [Register(source_location=structure_methods/contract.py:46:18-48, ir_type=Encoded(uint64), name='tmp%1', version=0)] +debug: Replacing redundant declaration let tmp%15#0: Encoded(uint64) = bytes_encode<(uint64)>(tmp%0#0) with copy of existing registers [Register(source_location=structure_methods/contract.py:46:18-48, ir_type=Encoded(uint64), name='tmp%1', version=0)] +debug: Found equivalence set: tmp%1#0, tmp%3#0, tmp%5#0, tmp%7#0, tmp%9#0, tmp%11#0, tmp%13#0, tmp%15#0 +debug: selected tmp%1#0 from equivalence set +debug: Copy propagation made 7 modifications +debug: Replacing redundant declaration let event%1#0: bytes = (concat method "ARC4TestStruct(uint64)" tmp%1#0) with copy of existing registers [Register(source_location=structure_methods/contract.py:46:8-49, ir_type=bytes, name='event%0', version=0)] +debug: Replacing redundant declaration let event%2#0: bytes = (concat method "ARC4TestStruct(uint64)" tmp%1#0) with copy of existing registers [Register(source_location=structure_methods/contract.py:46:8-49, ir_type=bytes, name='event%0', version=0)] +debug: Replacing redundant declaration let event%3#0: bytes = (concat method "ARC4TestStruct(uint64)" tmp%1#0) with copy of existing registers [Register(source_location=structure_methods/contract.py:46:8-49, ir_type=bytes, name='event%0', version=0)] +debug: Replacing redundant declaration let event%4#0: bytes = (concat method "ARC4TestStruct(uint64)" tmp%1#0) with copy of existing registers [Register(source_location=structure_methods/contract.py:46:8-49, ir_type=bytes, name='event%0', version=0)] +debug: Replacing redundant declaration let event%5#0: bytes = (concat method "ARC4TestStruct(uint64)" tmp%1#0) with copy of existing registers [Register(source_location=structure_methods/contract.py:46:8-49, ir_type=bytes, name='event%0', version=0)] +debug: Replacing redundant declaration let event%6#0: bytes = (concat method "ARC4TestStruct(uint64)" tmp%1#0) with copy of existing registers [Register(source_location=structure_methods/contract.py:46:8-49, ir_type=bytes, name='event%0', version=0)] +debug: Replacing redundant declaration let event%7#0: bytes = (concat method "ARC4TestStruct(uint64)" tmp%1#0) with copy of existing registers [Register(source_location=structure_methods/contract.py:46:8-49, ir_type=bytes, name='event%0', version=0)] +debug: Found equivalence set: event%0#0, event%1#0, event%2#0, event%3#0, event%4#0, event%5#0, event%6#0, event%7#0 +debug: selected event%0#0 from equivalence set +debug: Copy propagation made 7 modifications +debug: Optimizer: Encode Decode Pair Elimination +debug: Optimizer: Merge Chained Aggregate Reads +debug: Optimizer: Replace Aggregate Box Ops +debug: Optimizer: Minimize Box Exist Asserts +debug: Optimizer: Constant Reads And Unobserved Writes Elimination +debug: Optimizing subroutine test_cases.structure_methods.contract.GroupedMethods.usually_inlined +debug: Optimizer: Perform Subroutine Inlining +debug: Optimizer: Split Parallel Copies +debug: Optimizer: Constant Replacer +debug: Optimizer: Copy Propagation +debug: Optimizer: Elide Itxn Field Calls +debug: Optimizer: Remove Unused Variables +debug: Optimizer: Intrinsic Simplifier +debug: Optimizer: Inner Txn Field Replacer +debug: Optimizer: Replace Compiled References +debug: Optimizer: Simplify Control Ops +debug: Optimizer: Merge Blocks +debug: Optimizer: Remove Linear Jumps +debug: Optimizer: Remove Unreachable Blocks +debug: Optimizer: Repeated Expression Elimination +debug: Optimizer: Encode Decode Pair Elimination +debug: Optimizer: Merge Chained Aggregate Reads +debug: Optimizer: Replace Aggregate Box Ops +debug: Optimizer: Minimize Box Exist Asserts +debug: Optimizer: Constant Reads And Unobserved Writes Elimination +debug: Optimizing subroutine test_cases.structure_methods.contract.GroupedMethods.not_usually_inlined +debug: Optimizer: Perform Subroutine Inlining +debug: Optimizer: Split Parallel Copies +debug: Optimizer: Constant Replacer +debug: Optimizer: Copy Propagation +debug: Optimizer: Elide Itxn Field Calls +debug: Optimizer: Remove Unused Variables +debug: Optimizer: Intrinsic Simplifier +debug: Optimizer: Inner Txn Field Replacer +debug: Optimizer: Replace Compiled References +debug: Optimizer: Simplify Control Ops +debug: Optimizer: Merge Blocks +debug: Optimizer: Remove Linear Jumps +debug: Optimizer: Remove Unreachable Blocks +debug: Optimizer: Repeated Expression Elimination +debug: Replacing redundant declaration let tmp%2#0: Encoded(uint64) = bytes_encode(v#0) with copy of existing registers [Register(source_location=structure_methods/contract.py:59:33-47, ir_type=Encoded(uint64), name='tmp%0', version=0)] +debug: Replacing redundant declaration let tmp%4#0: Encoded(uint64) = bytes_encode(v#0) with copy of existing registers [Register(source_location=structure_methods/contract.py:59:33-47, ir_type=Encoded(uint64), name='tmp%0', version=0)] +debug: Replacing redundant declaration let tmp%6#0: Encoded(uint64) = bytes_encode(v#0) with copy of existing registers [Register(source_location=structure_methods/contract.py:59:33-47, ir_type=Encoded(uint64), name='tmp%0', version=0)] +debug: Replacing redundant declaration let tmp%8#0: Encoded(uint64) = bytes_encode(v#0) with copy of existing registers [Register(source_location=structure_methods/contract.py:59:33-47, ir_type=Encoded(uint64), name='tmp%0', version=0)] +debug: Replacing redundant declaration let tmp%10#0: Encoded(uint64) = bytes_encode(v#0) with copy of existing registers [Register(source_location=structure_methods/contract.py:59:33-47, ir_type=Encoded(uint64), name='tmp%0', version=0)] +debug: Replacing redundant declaration let tmp%12#0: Encoded(uint64) = bytes_encode(v#0) with copy of existing registers [Register(source_location=structure_methods/contract.py:59:33-47, ir_type=Encoded(uint64), name='tmp%0', version=0)] +debug: Replacing redundant declaration let tmp%14#0: Encoded(uint64) = bytes_encode(v#0) with copy of existing registers [Register(source_location=structure_methods/contract.py:59:33-47, ir_type=Encoded(uint64), name='tmp%0', version=0)] +debug: Found equivalence set: tmp%0#0, tmp%2#0, tmp%4#0, tmp%6#0, tmp%8#0, tmp%10#0, tmp%12#0, tmp%14#0 +debug: selected tmp%0#0 from equivalence set +debug: Copy propagation made 7 modifications +debug: Replacing redundant declaration let tmp%3#0: Encoded(uint64) = bytes_encode<(uint64)>(tmp%0#0) with copy of existing registers [Register(source_location=structure_methods/contract.py:59:18-48, ir_type=Encoded(uint64), name='tmp%1', version=0)] +debug: Replacing redundant declaration let tmp%5#0: Encoded(uint64) = bytes_encode<(uint64)>(tmp%0#0) with copy of existing registers [Register(source_location=structure_methods/contract.py:59:18-48, ir_type=Encoded(uint64), name='tmp%1', version=0)] +debug: Replacing redundant declaration let tmp%7#0: Encoded(uint64) = bytes_encode<(uint64)>(tmp%0#0) with copy of existing registers [Register(source_location=structure_methods/contract.py:59:18-48, ir_type=Encoded(uint64), name='tmp%1', version=0)] +debug: Replacing redundant declaration let tmp%9#0: Encoded(uint64) = bytes_encode<(uint64)>(tmp%0#0) with copy of existing registers [Register(source_location=structure_methods/contract.py:59:18-48, ir_type=Encoded(uint64), name='tmp%1', version=0)] +debug: Replacing redundant declaration let tmp%11#0: Encoded(uint64) = bytes_encode<(uint64)>(tmp%0#0) with copy of existing registers [Register(source_location=structure_methods/contract.py:59:18-48, ir_type=Encoded(uint64), name='tmp%1', version=0)] +debug: Replacing redundant declaration let tmp%13#0: Encoded(uint64) = bytes_encode<(uint64)>(tmp%0#0) with copy of existing registers [Register(source_location=structure_methods/contract.py:59:18-48, ir_type=Encoded(uint64), name='tmp%1', version=0)] +debug: Replacing redundant declaration let tmp%15#0: Encoded(uint64) = bytes_encode<(uint64)>(tmp%0#0) with copy of existing registers [Register(source_location=structure_methods/contract.py:59:18-48, ir_type=Encoded(uint64), name='tmp%1', version=0)] +debug: Found equivalence set: tmp%1#0, tmp%3#0, tmp%5#0, tmp%7#0, tmp%9#0, tmp%11#0, tmp%13#0, tmp%15#0 +debug: selected tmp%1#0 from equivalence set +debug: Copy propagation made 7 modifications +debug: Replacing redundant declaration let event%1#0: bytes = (concat method "ARC4TestStruct(uint64)" tmp%1#0) with copy of existing registers [Register(source_location=structure_methods/contract.py:59:8-49, ir_type=bytes, name='event%0', version=0)] +debug: Replacing redundant declaration let event%2#0: bytes = (concat method "ARC4TestStruct(uint64)" tmp%1#0) with copy of existing registers [Register(source_location=structure_methods/contract.py:59:8-49, ir_type=bytes, name='event%0', version=0)] +debug: Replacing redundant declaration let event%3#0: bytes = (concat method "ARC4TestStruct(uint64)" tmp%1#0) with copy of existing registers [Register(source_location=structure_methods/contract.py:59:8-49, ir_type=bytes, name='event%0', version=0)] +debug: Replacing redundant declaration let event%4#0: bytes = (concat method "ARC4TestStruct(uint64)" tmp%1#0) with copy of existing registers [Register(source_location=structure_methods/contract.py:59:8-49, ir_type=bytes, name='event%0', version=0)] +debug: Replacing redundant declaration let event%5#0: bytes = (concat method "ARC4TestStruct(uint64)" tmp%1#0) with copy of existing registers [Register(source_location=structure_methods/contract.py:59:8-49, ir_type=bytes, name='event%0', version=0)] +debug: Replacing redundant declaration let event%6#0: bytes = (concat method "ARC4TestStruct(uint64)" tmp%1#0) with copy of existing registers [Register(source_location=structure_methods/contract.py:59:8-49, ir_type=bytes, name='event%0', version=0)] +debug: Replacing redundant declaration let event%7#0: bytes = (concat method "ARC4TestStruct(uint64)" tmp%1#0) with copy of existing registers [Register(source_location=structure_methods/contract.py:59:8-49, ir_type=bytes, name='event%0', version=0)] +debug: Found equivalence set: event%0#0, event%1#0, event%2#0, event%3#0, event%4#0, event%5#0, event%6#0, event%7#0 +debug: selected event%0#0 from equivalence set +debug: Copy propagation made 7 modifications +debug: Optimizer: Encode Decode Pair Elimination +debug: Optimizer: Merge Chained Aggregate Reads +debug: Optimizer: Replace Aggregate Box Ops +debug: Optimizer: Minimize Box Exist Asserts +debug: Optimizer: Constant Reads And Unobserved Writes Elimination +debug: Optimizing subroutine test_cases.structure_methods.contract.TestContract.__puya_arc4_router__ +debug: Optimizer: Perform Subroutine Inlining +debug: inlining call to test_cases.structure_methods.contract.TestContract.__algopy_default_create in test_cases.structure_methods.contract.TestContract.__puya_arc4_router__ +structure_methods/contract.py:70:6 debug: inlining call to test_cases.structure_methods.contract.TestContract.test[routing] in test_cases.structure_methods.contract.TestContract.__puya_arc4_router__ +debug: Optimizer: Split Parallel Copies +debug: Optimizer: Constant Replacer +debug: Optimizer: Copy Propagation +debug: Optimizer: Elide Itxn Field Calls +debug: Optimizer: Remove Unused Variables +debug: Optimizer: Intrinsic Simplifier +debug: Simplified (== tmp%3#0 NoOp) to (! tmp%3#0) +debug: Simplified (&& tmp%4#0 tmp%6#0) to (&& tmp%4#0 tmp%5#0) +debug: Simplified (== tmp%8#0 NoOp) to (! tmp%8#0) +debug: Simplified (== tmp%10#0 0u) to (! tmp%10#0) +debug: Optimizer: Inner Txn Field Replacer +debug: Optimizer: Replace Compiled References +debug: Optimizer: Simplify Control Ops +debug: simplifying exit 0 to err +debug: simplified terminator of block@5 from exit 0u to fail +debug: Optimizer: Merge Blocks +debug: Merged linear block@8 into block@2 +debug: Replaced predecessor block@6 with block@4 in block@7 +debug: Merged linear block@6 into block@4 +debug: Merged linear block@7 into block@4 +debug: Merged linear block@5 into block@3 +debug: Optimizer: Remove Linear Jumps +debug: Removing jump block block@9 +debug: branching to block@9 will be replaced with block@3 +debug: Optimizer: Remove Unreachable Blocks +debug: Optimizer: Repeated Expression Elimination +debug: Optimizer: Encode Decode Pair Elimination +debug: Optimizer: Merge Chained Aggregate Reads +debug: Optimizer: Replace Aggregate Box Ops +debug: Optimizer: Minimize Box Exist Asserts +debug: Optimizer: Constant Reads And Unobserved Writes Elimination +debug: Optimizing subroutine test_cases.structure_methods.contract.TestContract.test[routing] +debug: Optimizer: Perform Subroutine Inlining +structure_methods/contract.py:70:6 debug: inlining call to test_cases.structure_methods.contract.TestContract.test in test_cases.structure_methods.contract.TestContract.test[routing] +debug: Optimizer: Split Parallel Copies +debug: Optimizer: Constant Replacer +debug: Optimizer: Copy Propagation +debug: Optimizer: Elide Itxn Field Calls +debug: Optimizer: Remove Unused Variables +debug: Optimizer: Intrinsic Simplifier +debug: Optimizer: Inner Txn Field Replacer +debug: Optimizer: Replace Compiled References +debug: Optimizer: Simplify Control Ops +debug: Optimizer: Merge Blocks +debug: Replaced predecessor block@1 with block@0 in block@2 +debug: Merged linear block@1 into block@0 +debug: Merged linear block@2 into block@0 +debug: Optimizer: Remove Linear Jumps +debug: Optimizer: Remove Unreachable Blocks +debug: Optimizer: Repeated Expression Elimination +debug: Replacing redundant declaration let tmp%6#0: Encoded(uint64) = bytes_encode<(uint64)>(0x0000000000000009) with copy of existing registers [Register(source_location=structure_methods/contract.py:73:29-59, ir_type=Encoded(uint64), name='tmp%0', version=0)] +debug: Replacing redundant declaration let tmp%8#0: Encoded(uint64) = bytes_encode<(uint64)>(9u) with copy of existing registers [Register(source_location=structure_methods/contract.py:74:29-50, ir_type=Encoded(uint64), name='tmp%2', version=0)] +debug: Found equivalence set: tmp%0#0, tmp%6#0 +debug: selected tmp%0#0 from equivalence set +debug: Found equivalence set: tmp%2#0, tmp%8#0 +debug: selected tmp%2#0 from equivalence set +debug: Copy propagation made 2 modifications +debug: Optimizer: Encode Decode Pair Elimination +debug: Optimizer: Merge Chained Aggregate Reads +debug: Optimizer: Replace Aggregate Box Ops +debug: Optimizer: Minimize Box Exist Asserts +debug: Optimizer: Constant Reads And Unobserved Writes Elimination +debug: Optimizing subroutine test_cases.structure_methods.contract.TestContract.test +debug: Optimizer: Perform Subroutine Inlining +structure_methods/contract.py:75:30 debug: constant function call to test_cases.structure_methods.contract.TestNamedTuple.return_value_times in test_cases.structure_methods.contract.TestContract.test +structure_methods/contract.py:82:30 debug: constant function call to test_cases.structure_methods.contract.TestNamedTuple.return_value_times in test_cases.structure_methods.contract.TestContract.test +structure_methods/contract.py:87:29 debug: inlining call to test_cases.structure_methods.contract.ARC4TestStruct.return1 in test_cases.structure_methods.contract.TestContract.test +structure_methods/contract.py:88:29 debug: inlining call to test_cases.structure_methods.contract.TestStruct.return1 in test_cases.structure_methods.contract.TestContract.test +structure_methods/contract.py:89:29 debug: inlining call to test_cases.structure_methods.contract.TestNamedTuple.return1 in test_cases.structure_methods.contract.TestContract.test +structure_methods/contract.py:92:29 debug: inlining call to test_cases.structure_methods.contract.ARC4TestStruct.return1 in test_cases.structure_methods.contract.TestContract.test +structure_methods/contract.py:93:29 debug: inlining call to test_cases.structure_methods.contract.TestStruct.return1 in test_cases.structure_methods.contract.TestContract.test +structure_methods/contract.py:94:29 debug: inlining call to test_cases.structure_methods.contract.TestNamedTuple.return1 in test_cases.structure_methods.contract.TestContract.test +structure_methods/contract.py:103:29 debug: constant function call to test_cases.structure_methods.contract.GroupedMethods.usually_inlined in test_cases.structure_methods.contract.TestContract.test +structure_methods/contract.py:104:29 debug: constant function call to test_cases.structure_methods.contract.GroupedMethods.usually_inlined in test_cases.structure_methods.contract.TestContract.test +structure_methods/contract.py:105:9 debug: inlining call to test_cases.structure_methods.contract.GroupedMethods.always_inlined_not_usually_inlined in test_cases.structure_methods.contract.TestContract.test +structure_methods/contract.py:106:9 debug: inlining call to test_cases.structure_methods.contract.GroupedMethods.always_inlined_not_usually_inlined in test_cases.structure_methods.contract.TestContract.test +debug: Optimizer: Split Parallel Copies +debug: Optimizer: Constant Replacer +debug: Optimizer: Copy Propagation +debug: Found equivalence set: tmp%0#1, tmp%4#0 +debug: selected tmp%0#1 from equivalence set +debug: Found equivalence set: tmp%0#2, tmp%10#0 +debug: selected tmp%0#2 from equivalence set +debug: Found equivalence set: tmp%0#3, tmp%28#0 +debug: selected tmp%0#3 from equivalence set +debug: Found equivalence set: tmp%0#4, tmp%30#0 +debug: selected tmp%0#4 from equivalence set +debug: Copy propagation made 4 modifications +debug: Optimizer: Elide Itxn Field Calls +debug: Optimizer: Remove Unused Variables +debug: Removing unused variable self.value#0 +debug: Removing unused variable times#0 +debug: Removing unused variable self.value#1 +debug: Removing unused variable times#1 +debug: Removing unused variable tmp%12#0 +debug: Removing unused variable tmp%14#0 +debug: Removing unused variable tmp%16#0 +debug: Removing unused variable tmp%18#0 +debug: Removing unused variable tmp%20#0 +debug: Removing unused variable tmp%22#0 +debug: Removing unused variable v#0 +debug: Removing unused variable v#1 +debug: Removing unused variable v#2 +debug: Removing unused variable v#3 +debug: Optimizer: Intrinsic Simplifier +debug: Simplified (* 9u 2u) to 18u +debug: Simplified (== 18u 18u) to 1u +debug: Simplified (* 9u 2u) to 18u +debug: Simplified (== 18u 18u) to 1u +debug: Simplified (== 1u 1u) to 1u +debug: Simplified (== 1u 1u) to 1u +debug: Simplified (== 1u 1u) to 1u +debug: Simplified (== 1u 1u) to 1u +debug: Simplified (== 1u 1u) to 1u +debug: Simplified (== 1u 1u) to 1u +debug: Simplified (+ 2u 1u) to 3u +debug: Simplified (== 3u 3u) to 1u +debug: Simplified (+ 2u 1u) to 3u +debug: Simplified (== 3u 3u) to 1u +debug: Optimizer: Inner Txn Field Replacer +debug: Optimizer: Replace Compiled References +debug: Optimizer: Simplify Control Ops +debug: Optimizer: Merge Blocks +debug: Replaced predecessor block@1 with block@0 in block@2 +debug: Merged linear block@1 into block@0 +debug: Replaced predecessor block@2 with block@0 in block@3 +debug: Merged linear block@2 into block@0 +debug: Replaced predecessor block@3 with block@0 in block@4 +debug: Merged linear block@3 into block@0 +debug: Replaced predecessor block@4 with block@0 in block@5 +debug: Merged linear block@4 into block@0 +debug: Replaced predecessor block@5 with block@0 in block@6 +debug: Merged linear block@5 into block@0 +debug: Replaced predecessor block@6 with block@0 in block@7 +debug: Merged linear block@6 into block@0 +debug: Replaced predecessor block@7 with block@0 in block@8 +debug: Merged linear block@7 into block@0 +debug: Replaced predecessor block@8 with block@0 in block@9 +debug: Merged linear block@8 into block@0 +debug: Replaced predecessor block@9 with block@0 in block@10 +debug: Merged linear block@9 into block@0 +debug: Replaced predecessor block@10 with block@0 in block@11 +debug: Merged linear block@10 into block@0 +debug: Replaced predecessor block@11 with block@0 in block@12 +debug: Merged linear block@11 into block@0 +debug: Replaced predecessor block@12 with block@0 in block@13 +debug: Merged linear block@12 into block@0 +debug: Replaced predecessor block@13 with block@0 in block@14 +debug: Merged linear block@13 into block@0 +debug: Replaced predecessor block@14 with block@0 in block@15 +debug: Merged linear block@14 into block@0 +debug: Replaced predecessor block@15 with block@0 in block@16 +debug: Merged linear block@15 into block@0 +debug: Replaced predecessor block@16 with block@0 in block@17 +debug: Merged linear block@16 into block@0 +debug: Replaced predecessor block@17 with block@0 in block@18 +debug: Merged linear block@17 into block@0 +debug: Replaced predecessor block@18 with block@0 in block@19 +debug: Merged linear block@18 into block@0 +debug: Replaced predecessor block@19 with block@0 in block@20 +debug: Merged linear block@19 into block@0 +debug: Replaced predecessor block@20 with block@0 in block@21 +debug: Merged linear block@20 into block@0 +debug: Replaced predecessor block@21 with block@0 in block@22 +debug: Merged linear block@21 into block@0 +debug: Replaced predecessor block@22 with block@0 in block@23 +debug: Merged linear block@22 into block@0 +debug: Replaced predecessor block@23 with block@0 in block@24 +debug: Merged linear block@23 into block@0 +debug: Merged linear block@24 into block@0 +debug: Optimizer: Remove Linear Jumps +debug: Optimizer: Remove Unreachable Blocks +debug: Optimizer: Repeated Expression Elimination +debug: Replacing redundant declaration let tmp%6#0: Encoded(uint64) = bytes_encode<(uint64)>(0x0000000000000009) with copy of existing registers [Register(source_location=structure_methods/contract.py:73:29-59, ir_type=Encoded(uint64), name='tmp%0', version=0)] +debug: Replacing redundant declaration let tmp%8#0: Encoded(uint64) = bytes_encode<(uint64)>(9u) with copy of existing registers [Register(source_location=structure_methods/contract.py:74:29-50, ir_type=Encoded(uint64), name='tmp%2', version=0)] +debug: Replacing redundant declaration let tmp%0#6: Encoded(uint64) = bytes_encode(2u) with copy of existing registers [Register(source_location=structure_methods/contract.py:46:33-47, ir_type=Encoded(uint64), name='tmp%0', version=5)] +debug: Found equivalence set: tmp%0#0, tmp%6#0 +debug: selected tmp%0#0 from equivalence set +debug: Found equivalence set: tmp%2#0, tmp%8#0 +debug: selected tmp%2#0 from equivalence set +debug: Found equivalence set: tmp%0#5, tmp%0#6 +debug: selected tmp%0#5 from equivalence set +debug: Copy propagation made 3 modifications +debug: Replacing redundant declaration let tmp%1#2: Encoded(uint64) = bytes_encode<(uint64)>(tmp%0#5) with copy of existing registers [Register(source_location=structure_methods/contract.py:46:18-48, ir_type=Encoded(uint64), name='tmp%1', version=1)] +debug: Found equivalence set: tmp%1#1, tmp%1#2 +debug: selected tmp%1#1 from equivalence set +debug: Copy propagation made 1 modifications +debug: Replacing redundant declaration let event%0#1: bytes = (concat method "ARC4TestStruct(uint64)" tmp%1#1) with copy of existing registers [Register(source_location=structure_methods/contract.py:46:8-49, ir_type=bytes, name='event%0', version=0)] +debug: Found equivalence set: event%0#0, event%0#1 +debug: selected event%0#0 from equivalence set +debug: Copy propagation made 8 modifications +debug: Optimizer: Encode Decode Pair Elimination +debug: Optimizer: Merge Chained Aggregate Reads +debug: Optimizer: Replace Aggregate Box Ops +debug: Optimizer: Minimize Box Exist Asserts +debug: Optimizer: Constant Reads And Unobserved Writes Elimination +debug: Optimizing subroutine test_cases.structure_methods.contract.TestContract.__algopy_default_create +debug: Optimizer: Perform Subroutine Inlining +debug: Optimizer: Split Parallel Copies +debug: Optimizer: Constant Replacer +debug: Optimizer: Copy Propagation +debug: Optimizer: Elide Itxn Field Calls +debug: Optimizer: Remove Unused Variables +debug: Optimizer: Intrinsic Simplifier +debug: Optimizer: Inner Txn Field Replacer +debug: Optimizer: Replace Compiled References +debug: Optimizer: Simplify Control Ops +debug: Optimizer: Merge Blocks +debug: Optimizer: Remove Linear Jumps +debug: Optimizer: Remove Unreachable Blocks +debug: Optimizer: Repeated Expression Elimination +debug: Optimizer: Encode Decode Pair Elimination +debug: Optimizer: Merge Chained Aggregate Reads +debug: Optimizer: Replace Aggregate Box Ops +debug: Optimizer: Minimize Box Exist Asserts +debug: Optimizer: Constant Reads And Unobserved Writes Elimination +debug: removing unused subroutine test_cases.structure_methods.contract.TestContract.__puya_arc4_router__ +debug: removing unused subroutine test_cases.structure_methods.contract.TestContract.test +debug: Unused subroutines removed +debug: Begin optimization pass 2/100 +debug: marking trivial method test_cases.structure_methods.contract.ARC4TestStruct.return1 as inlineable +debug: marking trivial method test_cases.structure_methods.contract.TestStruct.return1 as inlineable +debug: marking trivial method test_cases.structure_methods.contract.TestNamedTuple.return1 as inlineable +debug: marking single-use function test_cases.structure_methods.contract.TestContract.test[routing] for inlining +debug: Optimizing subroutine algopy.arc4.ARC4Contract.approval_program +debug: Optimizer: Perform Subroutine Inlining +debug: inlining call to test_cases.structure_methods.contract.TestContract.__algopy_default_create in algopy.arc4.ARC4Contract.approval_program +structure_methods/contract.py:70:6 debug: inlining call to test_cases.structure_methods.contract.TestContract.test[routing] in algopy.arc4.ARC4Contract.approval_program +debug: Optimizer: Split Parallel Copies +debug: Optimizer: Constant Replacer +debug: Optimizer: Copy Propagation +debug: Optimizer: Elide Itxn Field Calls +debug: Optimizer: Remove Unused Variables +debug: Removing unused variable tmp%1#0 +debug: Removing unused variable tmp%6#0 +debug: Optimizer: Intrinsic Simplifier +debug: Optimizer: Inner Txn Field Replacer +debug: Optimizer: Replace Compiled References +debug: Optimizer: Simplify Control Ops +debug: Optimizer: Merge Blocks +debug: Merged linear block@8 into block@3 +debug: Replaced predecessor block@6 with block@5 in block@7 +debug: Merged linear block@6 into block@5 +debug: Merged linear block@7 into block@5 +debug: Optimizer: Remove Linear Jumps +debug: Removing jump block block@9 +debug: branching to block@9 will be replaced with block@4 +debug: Optimizer: Remove Unreachable Blocks +debug: Optimizer: Repeated Expression Elimination +debug: Optimizer: Encode Decode Pair Elimination +debug: Optimizer: Merge Chained Aggregate Reads +debug: Optimizer: Replace Aggregate Box Ops +debug: Optimizer: Minimize Box Exist Asserts +debug: Optimizer: Constant Reads And Unobserved Writes Elimination +debug: Optimizing subroutine test_cases.structure_methods.contract.ARC4TestStruct.return_value_times +debug: Optimizer: Perform Subroutine Inlining +debug: Optimizer: Split Parallel Copies +debug: Optimizer: Constant Replacer +debug: Optimizer: Copy Propagation +debug: Optimizer: Elide Itxn Field Calls +debug: Optimizer: Remove Unused Variables +debug: Optimizer: Intrinsic Simplifier +debug: Optimizer: Inner Txn Field Replacer +debug: Optimizer: Replace Compiled References +debug: Optimizer: Simplify Control Ops +debug: Optimizer: Merge Blocks +debug: Optimizer: Remove Linear Jumps +debug: Optimizer: Remove Unreachable Blocks +debug: Optimizer: Repeated Expression Elimination +debug: Optimizer: Encode Decode Pair Elimination +debug: Optimizer: Merge Chained Aggregate Reads +debug: Optimizer: Replace Aggregate Box Ops +debug: Optimizer: Minimize Box Exist Asserts +debug: Optimizer: Constant Reads And Unobserved Writes Elimination +debug: Optimizing subroutine test_cases.structure_methods.contract.ARC4TestStruct.return1 +debug: Optimizer: Perform Subroutine Inlining +debug: Optimizer: Split Parallel Copies +debug: Optimizer: Constant Replacer +debug: Optimizer: Copy Propagation +debug: Optimizer: Elide Itxn Field Calls +debug: Optimizer: Remove Unused Variables +debug: Optimizer: Intrinsic Simplifier +debug: Optimizer: Inner Txn Field Replacer +debug: Optimizer: Replace Compiled References +debug: Optimizer: Simplify Control Ops +debug: Optimizer: Merge Blocks +debug: Optimizer: Remove Linear Jumps +debug: Optimizer: Remove Unreachable Blocks +debug: Optimizer: Repeated Expression Elimination +debug: Optimizer: Encode Decode Pair Elimination +debug: Optimizer: Merge Chained Aggregate Reads +debug: Optimizer: Replace Aggregate Box Ops +debug: Optimizer: Minimize Box Exist Asserts +debug: Optimizer: Constant Reads And Unobserved Writes Elimination +debug: Optimizing subroutine test_cases.structure_methods.contract.TestStruct.return_value_times +debug: Optimizer: Perform Subroutine Inlining +debug: Optimizer: Split Parallel Copies +debug: Optimizer: Constant Replacer +debug: Optimizer: Copy Propagation +debug: Optimizer: Elide Itxn Field Calls +debug: Optimizer: Remove Unused Variables +debug: Optimizer: Intrinsic Simplifier +debug: Optimizer: Inner Txn Field Replacer +debug: Optimizer: Replace Compiled References +debug: Optimizer: Simplify Control Ops +debug: Optimizer: Merge Blocks +debug: Optimizer: Remove Linear Jumps +debug: Optimizer: Remove Unreachable Blocks +debug: Optimizer: Repeated Expression Elimination +debug: Optimizer: Encode Decode Pair Elimination +debug: Optimizer: Merge Chained Aggregate Reads +debug: Optimizer: Replace Aggregate Box Ops +debug: Optimizer: Minimize Box Exist Asserts +debug: Optimizer: Constant Reads And Unobserved Writes Elimination +debug: Optimizing subroutine test_cases.structure_methods.contract.TestStruct.return1 +debug: Optimizer: Perform Subroutine Inlining +debug: Optimizer: Split Parallel Copies +debug: Optimizer: Constant Replacer +debug: Optimizer: Copy Propagation +debug: Optimizer: Elide Itxn Field Calls +debug: Optimizer: Remove Unused Variables +debug: Optimizer: Intrinsic Simplifier +debug: Optimizer: Inner Txn Field Replacer +debug: Optimizer: Replace Compiled References +debug: Optimizer: Simplify Control Ops +debug: Optimizer: Merge Blocks +debug: Optimizer: Remove Linear Jumps +debug: Optimizer: Remove Unreachable Blocks +debug: Optimizer: Repeated Expression Elimination +debug: Optimizer: Encode Decode Pair Elimination +debug: Optimizer: Merge Chained Aggregate Reads +debug: Optimizer: Replace Aggregate Box Ops +debug: Optimizer: Minimize Box Exist Asserts +debug: Optimizer: Constant Reads And Unobserved Writes Elimination +debug: Optimizing subroutine test_cases.structure_methods.contract.TestNamedTuple.return_value_times +debug: Optimizer: Perform Subroutine Inlining +debug: Optimizer: Split Parallel Copies +debug: Optimizer: Constant Replacer +debug: Optimizer: Copy Propagation +debug: Optimizer: Elide Itxn Field Calls +debug: Optimizer: Remove Unused Variables +debug: Optimizer: Intrinsic Simplifier +debug: Optimizer: Inner Txn Field Replacer +debug: Optimizer: Replace Compiled References +debug: Optimizer: Simplify Control Ops +debug: Optimizer: Merge Blocks +debug: Optimizer: Remove Linear Jumps +debug: Optimizer: Remove Unreachable Blocks +debug: Optimizer: Repeated Expression Elimination +debug: Optimizer: Encode Decode Pair Elimination +debug: Optimizer: Merge Chained Aggregate Reads +debug: Optimizer: Replace Aggregate Box Ops +debug: Optimizer: Minimize Box Exist Asserts +debug: Optimizer: Constant Reads And Unobserved Writes Elimination +debug: Optimizing subroutine test_cases.structure_methods.contract.TestNamedTuple.return1 +debug: Optimizer: Perform Subroutine Inlining +debug: Optimizer: Split Parallel Copies +debug: Optimizer: Constant Replacer +debug: Optimizer: Copy Propagation +debug: Optimizer: Elide Itxn Field Calls +debug: Optimizer: Remove Unused Variables +debug: Optimizer: Intrinsic Simplifier +debug: Optimizer: Inner Txn Field Replacer +debug: Optimizer: Replace Compiled References +debug: Optimizer: Simplify Control Ops +debug: Optimizer: Merge Blocks +debug: Optimizer: Remove Linear Jumps +debug: Optimizer: Remove Unreachable Blocks +debug: Optimizer: Repeated Expression Elimination +debug: Optimizer: Encode Decode Pair Elimination +debug: Optimizer: Merge Chained Aggregate Reads +debug: Optimizer: Replace Aggregate Box Ops +debug: Optimizer: Minimize Box Exist Asserts +debug: Optimizer: Constant Reads And Unobserved Writes Elimination +debug: Optimizing subroutine test_cases.structure_methods.contract.GroupedMethods.never_inlined_usually_inlined +debug: Optimizer: Perform Subroutine Inlining +debug: Optimizer: Split Parallel Copies +debug: Optimizer: Constant Replacer +debug: Optimizer: Copy Propagation +debug: Optimizer: Elide Itxn Field Calls +debug: Optimizer: Remove Unused Variables +debug: Optimizer: Intrinsic Simplifier +debug: Optimizer: Inner Txn Field Replacer +debug: Optimizer: Replace Compiled References +debug: Optimizer: Simplify Control Ops +debug: Optimizer: Merge Blocks +debug: Optimizer: Remove Linear Jumps +debug: Optimizer: Remove Unreachable Blocks +debug: Optimizer: Repeated Expression Elimination +debug: Optimizer: Encode Decode Pair Elimination +debug: Optimizer: Merge Chained Aggregate Reads +debug: Optimizer: Replace Aggregate Box Ops +debug: Optimizer: Minimize Box Exist Asserts +debug: Optimizer: Constant Reads And Unobserved Writes Elimination +debug: Optimizing subroutine test_cases.structure_methods.contract.GroupedMethods.always_inlined_not_usually_inlined +debug: Optimizer: Perform Subroutine Inlining +debug: Optimizer: Split Parallel Copies +debug: Optimizer: Constant Replacer +debug: Optimizer: Copy Propagation +debug: Optimizer: Elide Itxn Field Calls +debug: Optimizer: Remove Unused Variables +debug: Optimizer: Intrinsic Simplifier +debug: Optimizer: Inner Txn Field Replacer +debug: Optimizer: Replace Compiled References +debug: Optimizer: Simplify Control Ops +debug: Optimizer: Merge Blocks +debug: Optimizer: Remove Linear Jumps +debug: Optimizer: Remove Unreachable Blocks +debug: Optimizer: Repeated Expression Elimination +debug: Optimizer: Encode Decode Pair Elimination +debug: Optimizer: Merge Chained Aggregate Reads +debug: Optimizer: Replace Aggregate Box Ops +debug: Optimizer: Minimize Box Exist Asserts +debug: Optimizer: Constant Reads And Unobserved Writes Elimination +debug: Optimizing subroutine test_cases.structure_methods.contract.GroupedMethods.usually_inlined +debug: Optimizer: Perform Subroutine Inlining +debug: Optimizer: Split Parallel Copies +debug: Optimizer: Constant Replacer +debug: Optimizer: Copy Propagation +debug: Optimizer: Elide Itxn Field Calls +debug: Optimizer: Remove Unused Variables +debug: Optimizer: Intrinsic Simplifier +debug: Optimizer: Inner Txn Field Replacer +debug: Optimizer: Replace Compiled References +debug: Optimizer: Simplify Control Ops +debug: Optimizer: Merge Blocks +debug: Optimizer: Remove Linear Jumps +debug: Optimizer: Remove Unreachable Blocks +debug: Optimizer: Repeated Expression Elimination +debug: Optimizer: Encode Decode Pair Elimination +debug: Optimizer: Merge Chained Aggregate Reads +debug: Optimizer: Replace Aggregate Box Ops +debug: Optimizer: Minimize Box Exist Asserts +debug: Optimizer: Constant Reads And Unobserved Writes Elimination +debug: Optimizing subroutine test_cases.structure_methods.contract.GroupedMethods.not_usually_inlined +debug: Optimizer: Perform Subroutine Inlining +debug: Optimizer: Split Parallel Copies +debug: Optimizer: Constant Replacer +debug: Optimizer: Copy Propagation +debug: Optimizer: Elide Itxn Field Calls +debug: Optimizer: Remove Unused Variables +debug: Optimizer: Intrinsic Simplifier +debug: Optimizer: Inner Txn Field Replacer +debug: Optimizer: Replace Compiled References +debug: Optimizer: Simplify Control Ops +debug: Optimizer: Merge Blocks +debug: Optimizer: Remove Linear Jumps +debug: Optimizer: Remove Unreachable Blocks +debug: Optimizer: Repeated Expression Elimination +debug: Optimizer: Encode Decode Pair Elimination +debug: Optimizer: Merge Chained Aggregate Reads +debug: Optimizer: Replace Aggregate Box Ops +debug: Optimizer: Minimize Box Exist Asserts +debug: Optimizer: Constant Reads And Unobserved Writes Elimination +debug: Optimizing subroutine test_cases.structure_methods.contract.TestContract.test[routing] +debug: Optimizer: Perform Subroutine Inlining +structure_methods/contract.py:75:30 debug: constant function call to test_cases.structure_methods.contract.TestNamedTuple.return_value_times in test_cases.structure_methods.contract.TestContract.test[routing] +structure_methods/contract.py:82:30 debug: constant function call to test_cases.structure_methods.contract.TestNamedTuple.return_value_times in test_cases.structure_methods.contract.TestContract.test[routing] +structure_methods/contract.py:87:29 debug: inlining call to test_cases.structure_methods.contract.ARC4TestStruct.return1 in test_cases.structure_methods.contract.TestContract.test[routing] +structure_methods/contract.py:88:29 debug: inlining call to test_cases.structure_methods.contract.TestStruct.return1 in test_cases.structure_methods.contract.TestContract.test[routing] +structure_methods/contract.py:89:29 debug: inlining call to test_cases.structure_methods.contract.TestNamedTuple.return1 in test_cases.structure_methods.contract.TestContract.test[routing] +structure_methods/contract.py:92:29 debug: inlining call to test_cases.structure_methods.contract.ARC4TestStruct.return1 in test_cases.structure_methods.contract.TestContract.test[routing] +structure_methods/contract.py:93:29 debug: inlining call to test_cases.structure_methods.contract.TestStruct.return1 in test_cases.structure_methods.contract.TestContract.test[routing] +structure_methods/contract.py:94:29 debug: inlining call to test_cases.structure_methods.contract.TestNamedTuple.return1 in test_cases.structure_methods.contract.TestContract.test[routing] +structure_methods/contract.py:103:29 debug: constant function call to test_cases.structure_methods.contract.GroupedMethods.usually_inlined in test_cases.structure_methods.contract.TestContract.test[routing] +structure_methods/contract.py:104:29 debug: constant function call to test_cases.structure_methods.contract.GroupedMethods.usually_inlined in test_cases.structure_methods.contract.TestContract.test[routing] +structure_methods/contract.py:105:9 debug: inlining call to test_cases.structure_methods.contract.GroupedMethods.always_inlined_not_usually_inlined in test_cases.structure_methods.contract.TestContract.test[routing] +structure_methods/contract.py:106:9 debug: inlining call to test_cases.structure_methods.contract.GroupedMethods.always_inlined_not_usually_inlined in test_cases.structure_methods.contract.TestContract.test[routing] +debug: Optimizer: Split Parallel Copies +debug: Optimizer: Constant Replacer +debug: Optimizer: Copy Propagation +debug: Found equivalence set: tmp%0#1, tmp%4#0 +debug: selected tmp%0#1 from equivalence set +debug: Found equivalence set: tmp%0#2, tmp%10#0 +debug: selected tmp%0#2 from equivalence set +debug: Found equivalence set: tmp%0#3, tmp%28#0 +debug: selected tmp%0#3 from equivalence set +debug: Found equivalence set: tmp%0#4, tmp%30#0 +debug: selected tmp%0#4 from equivalence set +debug: Copy propagation made 4 modifications +debug: Optimizer: Elide Itxn Field Calls +debug: Optimizer: Remove Unused Variables +debug: Removing unused variable self.value#0 +debug: Removing unused variable times#0 +debug: Removing unused variable self.value#1 +debug: Removing unused variable times#1 +debug: Removing unused variable tmp%12#0 +debug: Removing unused variable tmp%14#0 +debug: Removing unused variable tmp%16#0 +debug: Removing unused variable tmp%18#0 +debug: Removing unused variable tmp%20#0 +debug: Removing unused variable tmp%22#0 +debug: Removing unused variable v#0 +debug: Removing unused variable v#1 +debug: Removing unused variable v#2 +debug: Removing unused variable v#3 +debug: Optimizer: Intrinsic Simplifier +debug: Simplified (* 9u 2u) to 18u +debug: Simplified (== 18u 18u) to 1u +debug: Simplified (* 9u 2u) to 18u +debug: Simplified (== 18u 18u) to 1u +debug: Simplified (== 1u 1u) to 1u +debug: Simplified (== 1u 1u) to 1u +debug: Simplified (== 1u 1u) to 1u +debug: Simplified (== 1u 1u) to 1u +debug: Simplified (== 1u 1u) to 1u +debug: Simplified (== 1u 1u) to 1u +debug: Simplified (+ 2u 1u) to 3u +debug: Simplified (== 3u 3u) to 1u +debug: Simplified (+ 2u 1u) to 3u +debug: Simplified (== 3u 3u) to 1u +debug: Optimizer: Inner Txn Field Replacer +debug: Optimizer: Replace Compiled References +debug: Optimizer: Simplify Control Ops +debug: Optimizer: Merge Blocks +debug: Replaced predecessor block@1 with block@0 in block@2 +debug: Merged linear block@1 into block@0 +debug: Replaced predecessor block@2 with block@0 in block@3 +debug: Merged linear block@2 into block@0 +debug: Replaced predecessor block@3 with block@0 in block@4 +debug: Merged linear block@3 into block@0 +debug: Replaced predecessor block@4 with block@0 in block@5 +debug: Merged linear block@4 into block@0 +debug: Replaced predecessor block@5 with block@0 in block@6 +debug: Merged linear block@5 into block@0 +debug: Replaced predecessor block@6 with block@0 in block@7 +debug: Merged linear block@6 into block@0 +debug: Replaced predecessor block@7 with block@0 in block@8 +debug: Merged linear block@7 into block@0 +debug: Replaced predecessor block@8 with block@0 in block@9 +debug: Merged linear block@8 into block@0 +debug: Replaced predecessor block@9 with block@0 in block@10 +debug: Merged linear block@9 into block@0 +debug: Replaced predecessor block@10 with block@0 in block@11 +debug: Merged linear block@10 into block@0 +debug: Replaced predecessor block@11 with block@0 in block@12 +debug: Merged linear block@11 into block@0 +debug: Replaced predecessor block@12 with block@0 in block@13 +debug: Merged linear block@12 into block@0 +debug: Replaced predecessor block@13 with block@0 in block@14 +debug: Merged linear block@13 into block@0 +debug: Replaced predecessor block@14 with block@0 in block@15 +debug: Merged linear block@14 into block@0 +debug: Replaced predecessor block@15 with block@0 in block@16 +debug: Merged linear block@15 into block@0 +debug: Replaced predecessor block@16 with block@0 in block@17 +debug: Merged linear block@16 into block@0 +debug: Replaced predecessor block@17 with block@0 in block@18 +debug: Merged linear block@17 into block@0 +debug: Replaced predecessor block@18 with block@0 in block@19 +debug: Merged linear block@18 into block@0 +debug: Replaced predecessor block@19 with block@0 in block@20 +debug: Merged linear block@19 into block@0 +debug: Replaced predecessor block@20 with block@0 in block@21 +debug: Merged linear block@20 into block@0 +debug: Replaced predecessor block@21 with block@0 in block@22 +debug: Merged linear block@21 into block@0 +debug: Replaced predecessor block@22 with block@0 in block@23 +debug: Merged linear block@22 into block@0 +debug: Replaced predecessor block@23 with block@0 in block@24 +debug: Merged linear block@23 into block@0 +debug: Merged linear block@24 into block@0 +debug: Optimizer: Remove Linear Jumps +debug: Optimizer: Remove Unreachable Blocks +debug: Optimizer: Repeated Expression Elimination +debug: Replacing redundant declaration let tmp%0#6: Encoded(uint64) = bytes_encode(2u) with copy of existing registers [Register(source_location=structure_methods/contract.py:46:33-47, ir_type=Encoded(uint64), name='tmp%0', version=5)] +debug: Found equivalence set: tmp%0#5, tmp%0#6 +debug: selected tmp%0#5 from equivalence set +debug: Copy propagation made 1 modifications +debug: Replacing redundant declaration let tmp%1#2: Encoded(uint64) = bytes_encode<(uint64)>(tmp%0#5) with copy of existing registers [Register(source_location=structure_methods/contract.py:46:18-48, ir_type=Encoded(uint64), name='tmp%1', version=1)] +debug: Found equivalence set: tmp%1#1, tmp%1#2 +debug: selected tmp%1#1 from equivalence set +debug: Copy propagation made 1 modifications +debug: Replacing redundant declaration let event%0#1: bytes = (concat method "ARC4TestStruct(uint64)" tmp%1#1) with copy of existing registers [Register(source_location=structure_methods/contract.py:46:8-49, ir_type=bytes, name='event%0', version=0)] +debug: Found equivalence set: event%0#0, event%0#1 +debug: selected event%0#0 from equivalence set +debug: Copy propagation made 8 modifications +debug: Optimizer: Encode Decode Pair Elimination +debug: Optimizer: Merge Chained Aggregate Reads +debug: Optimizer: Replace Aggregate Box Ops +debug: Optimizer: Minimize Box Exist Asserts +debug: Optimizer: Constant Reads And Unobserved Writes Elimination +debug: Optimizing subroutine test_cases.structure_methods.contract.TestContract.__algopy_default_create +debug: Optimizer: Perform Subroutine Inlining +debug: Optimizer: Split Parallel Copies +debug: Optimizer: Constant Replacer +debug: Optimizer: Copy Propagation +debug: Optimizer: Elide Itxn Field Calls +debug: Optimizer: Remove Unused Variables +debug: Optimizer: Intrinsic Simplifier +debug: Optimizer: Inner Txn Field Replacer +debug: Optimizer: Replace Compiled References +debug: Optimizer: Simplify Control Ops +debug: Optimizer: Merge Blocks +debug: Optimizer: Remove Linear Jumps +debug: Optimizer: Remove Unreachable Blocks +debug: Optimizer: Repeated Expression Elimination +debug: Optimizer: Encode Decode Pair Elimination +debug: Optimizer: Merge Chained Aggregate Reads +debug: Optimizer: Replace Aggregate Box Ops +debug: Optimizer: Minimize Box Exist Asserts +debug: Optimizer: Constant Reads And Unobserved Writes Elimination +debug: removing unused subroutine test_cases.structure_methods.contract.TestContract.test[routing] +debug: removing unused subroutine test_cases.structure_methods.contract.TestContract.__algopy_default_create +debug: Unused subroutines removed +debug: Begin optimization pass 3/100 +debug: marking trivial method test_cases.structure_methods.contract.ARC4TestStruct.return1 as inlineable +debug: marking trivial method test_cases.structure_methods.contract.TestStruct.return1 as inlineable +debug: marking trivial method test_cases.structure_methods.contract.TestNamedTuple.return1 as inlineable +debug: Optimizing subroutine algopy.arc4.ARC4Contract.approval_program +debug: Optimizer: Perform Subroutine Inlining +structure_methods/contract.py:75:30 debug: constant function call to test_cases.structure_methods.contract.TestNamedTuple.return_value_times in algopy.arc4.ARC4Contract.approval_program +structure_methods/contract.py:82:30 debug: constant function call to test_cases.structure_methods.contract.TestNamedTuple.return_value_times in algopy.arc4.ARC4Contract.approval_program +structure_methods/contract.py:87:29 debug: inlining call to test_cases.structure_methods.contract.ARC4TestStruct.return1 in algopy.arc4.ARC4Contract.approval_program +structure_methods/contract.py:88:29 debug: inlining call to test_cases.structure_methods.contract.TestStruct.return1 in algopy.arc4.ARC4Contract.approval_program +structure_methods/contract.py:89:29 debug: inlining call to test_cases.structure_methods.contract.TestNamedTuple.return1 in algopy.arc4.ARC4Contract.approval_program +structure_methods/contract.py:92:29 debug: inlining call to test_cases.structure_methods.contract.ARC4TestStruct.return1 in algopy.arc4.ARC4Contract.approval_program +structure_methods/contract.py:93:29 debug: inlining call to test_cases.structure_methods.contract.TestStruct.return1 in algopy.arc4.ARC4Contract.approval_program +structure_methods/contract.py:94:29 debug: inlining call to test_cases.structure_methods.contract.TestNamedTuple.return1 in algopy.arc4.ARC4Contract.approval_program +structure_methods/contract.py:103:29 debug: constant function call to test_cases.structure_methods.contract.GroupedMethods.usually_inlined in algopy.arc4.ARC4Contract.approval_program +structure_methods/contract.py:104:29 debug: constant function call to test_cases.structure_methods.contract.GroupedMethods.usually_inlined in algopy.arc4.ARC4Contract.approval_program +structure_methods/contract.py:105:9 debug: inlining call to test_cases.structure_methods.contract.GroupedMethods.always_inlined_not_usually_inlined in algopy.arc4.ARC4Contract.approval_program +structure_methods/contract.py:106:9 debug: inlining call to test_cases.structure_methods.contract.GroupedMethods.always_inlined_not_usually_inlined in algopy.arc4.ARC4Contract.approval_program +debug: Optimizer: Split Parallel Copies +debug: Optimizer: Constant Replacer +debug: Optimizer: Copy Propagation +debug: Found equivalence set: tmp%0#3, tmp%4#1 +debug: selected tmp%0#3 from equivalence set +debug: Found equivalence set: tmp%0#4, tmp%10#1 +debug: selected tmp%0#4 from equivalence set +debug: Found equivalence set: tmp%0#5, tmp%28#0 +debug: selected tmp%0#5 from equivalence set +debug: Found equivalence set: tmp%0#6, tmp%30#0 +debug: selected tmp%0#6 from equivalence set +debug: Copy propagation made 4 modifications +debug: Optimizer: Elide Itxn Field Calls +debug: Optimizer: Remove Unused Variables +debug: Removing unused variable self.value#0 +debug: Removing unused variable times#0 +debug: Removing unused variable self.value#1 +debug: Removing unused variable times#1 +debug: Removing unused variable tmp%12#1 +debug: Removing unused variable tmp%14#0 +debug: Removing unused variable tmp%16#0 +debug: Removing unused variable tmp%18#0 +debug: Removing unused variable tmp%20#0 +debug: Removing unused variable tmp%22#0 +debug: Removing unused variable v#0 +debug: Removing unused variable v#1 +debug: Removing unused variable v#2 +debug: Removing unused variable v#3 +debug: Optimizer: Intrinsic Simplifier +debug: Simplified (* 9u 2u) to 18u +debug: Simplified (== 18u 18u) to 1u +debug: Simplified (* 9u 2u) to 18u +debug: Simplified (== 18u 18u) to 1u +debug: Simplified (== 1u 1u) to 1u +debug: Simplified (== 1u 1u) to 1u +debug: Simplified (== 1u 1u) to 1u +debug: Simplified (== 1u 1u) to 1u +debug: Simplified (== 1u 1u) to 1u +debug: Simplified (== 1u 1u) to 1u +debug: Simplified (+ 2u 1u) to 3u +debug: Simplified (== 3u 3u) to 1u +debug: Simplified (+ 2u 1u) to 3u +debug: Simplified (== 3u 3u) to 1u +debug: Optimizer: Inner Txn Field Replacer +debug: Optimizer: Replace Compiled References +debug: Optimizer: Simplify Control Ops +debug: Optimizer: Merge Blocks +debug: Replaced predecessor block@6 with block@3 in block@7 +debug: Merged linear block@6 into block@3 +debug: Replaced predecessor block@7 with block@3 in block@8 +debug: Merged linear block@7 into block@3 +debug: Replaced predecessor block@8 with block@3 in block@9 +debug: Merged linear block@8 into block@3 +debug: Replaced predecessor block@9 with block@3 in block@10 +debug: Merged linear block@9 into block@3 +debug: Replaced predecessor block@10 with block@3 in block@11 +debug: Merged linear block@10 into block@3 +debug: Replaced predecessor block@11 with block@3 in block@12 +debug: Merged linear block@11 into block@3 +debug: Replaced predecessor block@12 with block@3 in block@13 +debug: Merged linear block@12 into block@3 +debug: Replaced predecessor block@13 with block@3 in block@14 +debug: Merged linear block@13 into block@3 +debug: Replaced predecessor block@14 with block@3 in block@15 +debug: Merged linear block@14 into block@3 +debug: Replaced predecessor block@15 with block@3 in block@16 +debug: Merged linear block@15 into block@3 +debug: Replaced predecessor block@16 with block@3 in block@17 +debug: Merged linear block@16 into block@3 +debug: Replaced predecessor block@17 with block@3 in block@18 +debug: Merged linear block@17 into block@3 +debug: Replaced predecessor block@18 with block@3 in block@19 +debug: Merged linear block@18 into block@3 +debug: Replaced predecessor block@19 with block@3 in block@20 +debug: Merged linear block@19 into block@3 +debug: Replaced predecessor block@20 with block@3 in block@21 +debug: Merged linear block@20 into block@3 +debug: Replaced predecessor block@21 with block@3 in block@22 +debug: Merged linear block@21 into block@3 +debug: Replaced predecessor block@22 with block@3 in block@23 +debug: Merged linear block@22 into block@3 +debug: Replaced predecessor block@23 with block@3 in block@24 +debug: Merged linear block@23 into block@3 +debug: Replaced predecessor block@24 with block@3 in block@25 +debug: Merged linear block@24 into block@3 +debug: Replaced predecessor block@25 with block@3 in block@26 +debug: Merged linear block@25 into block@3 +debug: Replaced predecessor block@26 with block@3 in block@27 +debug: Merged linear block@26 into block@3 +debug: Replaced predecessor block@27 with block@3 in block@28 +debug: Merged linear block@27 into block@3 +debug: Replaced predecessor block@28 with block@3 in block@29 +debug: Merged linear block@28 into block@3 +debug: Merged linear block@29 into block@3 +debug: Optimizer: Remove Linear Jumps +debug: Optimizer: Remove Unreachable Blocks +debug: Optimizer: Repeated Expression Elimination +debug: Replacing redundant declaration let tmp%0#8: Encoded(uint64) = bytes_encode(2u) with copy of existing registers [Register(source_location=structure_methods/contract.py:46:33-47, ir_type=Encoded(uint64), name='tmp%0', version=7)] +debug: Found equivalence set: tmp%0#7, tmp%0#8 +debug: selected tmp%0#7 from equivalence set +debug: Copy propagation made 1 modifications +debug: Replacing redundant declaration let tmp%1#3: Encoded(uint64) = bytes_encode<(uint64)>(tmp%0#7) with copy of existing registers [Register(source_location=structure_methods/contract.py:46:18-48, ir_type=Encoded(uint64), name='tmp%1', version=2)] +debug: Found equivalence set: tmp%1#2, tmp%1#3 +debug: selected tmp%1#2 from equivalence set +debug: Copy propagation made 1 modifications +debug: Replacing redundant declaration let event%0#1: bytes = (concat method "ARC4TestStruct(uint64)" tmp%1#2) with copy of existing registers [Register(source_location=structure_methods/contract.py:46:8-49, ir_type=bytes, name='event%0', version=0)] +debug: Found equivalence set: event%0#0, event%0#1 +debug: selected event%0#0 from equivalence set +debug: Copy propagation made 8 modifications +debug: Optimizer: Encode Decode Pair Elimination +debug: Optimizer: Merge Chained Aggregate Reads +debug: Optimizer: Replace Aggregate Box Ops +debug: Optimizer: Minimize Box Exist Asserts +debug: Optimizer: Constant Reads And Unobserved Writes Elimination +debug: Optimizing subroutine test_cases.structure_methods.contract.ARC4TestStruct.return_value_times +debug: Optimizer: Perform Subroutine Inlining +debug: Optimizer: Split Parallel Copies +debug: Optimizer: Constant Replacer +debug: Optimizer: Copy Propagation +debug: Optimizer: Elide Itxn Field Calls +debug: Optimizer: Remove Unused Variables +debug: Optimizer: Intrinsic Simplifier +debug: Optimizer: Inner Txn Field Replacer +debug: Optimizer: Replace Compiled References +debug: Optimizer: Simplify Control Ops +debug: Optimizer: Merge Blocks +debug: Optimizer: Remove Linear Jumps +debug: Optimizer: Remove Unreachable Blocks +debug: Optimizer: Repeated Expression Elimination +debug: Optimizer: Encode Decode Pair Elimination +debug: Optimizer: Merge Chained Aggregate Reads +debug: Optimizer: Replace Aggregate Box Ops +debug: Optimizer: Minimize Box Exist Asserts +debug: Optimizer: Constant Reads And Unobserved Writes Elimination +debug: Optimizing subroutine test_cases.structure_methods.contract.ARC4TestStruct.return1 +debug: Optimizer: Perform Subroutine Inlining +debug: Optimizer: Split Parallel Copies +debug: Optimizer: Constant Replacer +debug: Optimizer: Copy Propagation +debug: Optimizer: Elide Itxn Field Calls +debug: Optimizer: Remove Unused Variables +debug: Optimizer: Intrinsic Simplifier +debug: Optimizer: Inner Txn Field Replacer +debug: Optimizer: Replace Compiled References +debug: Optimizer: Simplify Control Ops +debug: Optimizer: Merge Blocks +debug: Optimizer: Remove Linear Jumps +debug: Optimizer: Remove Unreachable Blocks +debug: Optimizer: Repeated Expression Elimination +debug: Optimizer: Encode Decode Pair Elimination +debug: Optimizer: Merge Chained Aggregate Reads +debug: Optimizer: Replace Aggregate Box Ops +debug: Optimizer: Minimize Box Exist Asserts +debug: Optimizer: Constant Reads And Unobserved Writes Elimination +debug: Optimizing subroutine test_cases.structure_methods.contract.TestStruct.return_value_times +debug: Optimizer: Perform Subroutine Inlining +debug: Optimizer: Split Parallel Copies +debug: Optimizer: Constant Replacer +debug: Optimizer: Copy Propagation +debug: Optimizer: Elide Itxn Field Calls +debug: Optimizer: Remove Unused Variables +debug: Optimizer: Intrinsic Simplifier +debug: Optimizer: Inner Txn Field Replacer +debug: Optimizer: Replace Compiled References +debug: Optimizer: Simplify Control Ops +debug: Optimizer: Merge Blocks +debug: Optimizer: Remove Linear Jumps +debug: Optimizer: Remove Unreachable Blocks +debug: Optimizer: Repeated Expression Elimination +debug: Optimizer: Encode Decode Pair Elimination +debug: Optimizer: Merge Chained Aggregate Reads +debug: Optimizer: Replace Aggregate Box Ops +debug: Optimizer: Minimize Box Exist Asserts +debug: Optimizer: Constant Reads And Unobserved Writes Elimination +debug: Optimizing subroutine test_cases.structure_methods.contract.TestStruct.return1 +debug: Optimizer: Perform Subroutine Inlining +debug: Optimizer: Split Parallel Copies +debug: Optimizer: Constant Replacer +debug: Optimizer: Copy Propagation +debug: Optimizer: Elide Itxn Field Calls +debug: Optimizer: Remove Unused Variables +debug: Optimizer: Intrinsic Simplifier +debug: Optimizer: Inner Txn Field Replacer +debug: Optimizer: Replace Compiled References +debug: Optimizer: Simplify Control Ops +debug: Optimizer: Merge Blocks +debug: Optimizer: Remove Linear Jumps +debug: Optimizer: Remove Unreachable Blocks +debug: Optimizer: Repeated Expression Elimination +debug: Optimizer: Encode Decode Pair Elimination +debug: Optimizer: Merge Chained Aggregate Reads +debug: Optimizer: Replace Aggregate Box Ops +debug: Optimizer: Minimize Box Exist Asserts +debug: Optimizer: Constant Reads And Unobserved Writes Elimination +debug: Optimizing subroutine test_cases.structure_methods.contract.TestNamedTuple.return_value_times +debug: Optimizer: Perform Subroutine Inlining +debug: Optimizer: Split Parallel Copies +debug: Optimizer: Constant Replacer +debug: Optimizer: Copy Propagation +debug: Optimizer: Elide Itxn Field Calls +debug: Optimizer: Remove Unused Variables +debug: Optimizer: Intrinsic Simplifier +debug: Optimizer: Inner Txn Field Replacer +debug: Optimizer: Replace Compiled References +debug: Optimizer: Simplify Control Ops +debug: Optimizer: Merge Blocks +debug: Optimizer: Remove Linear Jumps +debug: Optimizer: Remove Unreachable Blocks +debug: Optimizer: Repeated Expression Elimination +debug: Optimizer: Encode Decode Pair Elimination +debug: Optimizer: Merge Chained Aggregate Reads +debug: Optimizer: Replace Aggregate Box Ops +debug: Optimizer: Minimize Box Exist Asserts +debug: Optimizer: Constant Reads And Unobserved Writes Elimination +debug: Optimizing subroutine test_cases.structure_methods.contract.TestNamedTuple.return1 +debug: Optimizer: Perform Subroutine Inlining +debug: Optimizer: Split Parallel Copies +debug: Optimizer: Constant Replacer +debug: Optimizer: Copy Propagation +debug: Optimizer: Elide Itxn Field Calls +debug: Optimizer: Remove Unused Variables +debug: Optimizer: Intrinsic Simplifier +debug: Optimizer: Inner Txn Field Replacer +debug: Optimizer: Replace Compiled References +debug: Optimizer: Simplify Control Ops +debug: Optimizer: Merge Blocks +debug: Optimizer: Remove Linear Jumps +debug: Optimizer: Remove Unreachable Blocks +debug: Optimizer: Repeated Expression Elimination +debug: Optimizer: Encode Decode Pair Elimination +debug: Optimizer: Merge Chained Aggregate Reads +debug: Optimizer: Replace Aggregate Box Ops +debug: Optimizer: Minimize Box Exist Asserts +debug: Optimizer: Constant Reads And Unobserved Writes Elimination +debug: Optimizing subroutine test_cases.structure_methods.contract.GroupedMethods.never_inlined_usually_inlined +debug: Optimizer: Perform Subroutine Inlining +debug: Optimizer: Split Parallel Copies +debug: Optimizer: Constant Replacer +debug: Optimizer: Copy Propagation +debug: Optimizer: Elide Itxn Field Calls +debug: Optimizer: Remove Unused Variables +debug: Optimizer: Intrinsic Simplifier +debug: Optimizer: Inner Txn Field Replacer +debug: Optimizer: Replace Compiled References +debug: Optimizer: Simplify Control Ops +debug: Optimizer: Merge Blocks +debug: Optimizer: Remove Linear Jumps +debug: Optimizer: Remove Unreachable Blocks +debug: Optimizer: Repeated Expression Elimination +debug: Optimizer: Encode Decode Pair Elimination +debug: Optimizer: Merge Chained Aggregate Reads +debug: Optimizer: Replace Aggregate Box Ops +debug: Optimizer: Minimize Box Exist Asserts +debug: Optimizer: Constant Reads And Unobserved Writes Elimination +debug: Optimizing subroutine test_cases.structure_methods.contract.GroupedMethods.always_inlined_not_usually_inlined +debug: Optimizer: Perform Subroutine Inlining +debug: Optimizer: Split Parallel Copies +debug: Optimizer: Constant Replacer +debug: Optimizer: Copy Propagation +debug: Optimizer: Elide Itxn Field Calls +debug: Optimizer: Remove Unused Variables +debug: Optimizer: Intrinsic Simplifier +debug: Optimizer: Inner Txn Field Replacer +debug: Optimizer: Replace Compiled References +debug: Optimizer: Simplify Control Ops +debug: Optimizer: Merge Blocks +debug: Optimizer: Remove Linear Jumps +debug: Optimizer: Remove Unreachable Blocks +debug: Optimizer: Repeated Expression Elimination +debug: Optimizer: Encode Decode Pair Elimination +debug: Optimizer: Merge Chained Aggregate Reads +debug: Optimizer: Replace Aggregate Box Ops +debug: Optimizer: Minimize Box Exist Asserts +debug: Optimizer: Constant Reads And Unobserved Writes Elimination +debug: Optimizing subroutine test_cases.structure_methods.contract.GroupedMethods.usually_inlined +debug: Optimizer: Perform Subroutine Inlining +debug: Optimizer: Split Parallel Copies +debug: Optimizer: Constant Replacer +debug: Optimizer: Copy Propagation +debug: Optimizer: Elide Itxn Field Calls +debug: Optimizer: Remove Unused Variables +debug: Optimizer: Intrinsic Simplifier +debug: Optimizer: Inner Txn Field Replacer +debug: Optimizer: Replace Compiled References +debug: Optimizer: Simplify Control Ops +debug: Optimizer: Merge Blocks +debug: Optimizer: Remove Linear Jumps +debug: Optimizer: Remove Unreachable Blocks +debug: Optimizer: Repeated Expression Elimination +debug: Optimizer: Encode Decode Pair Elimination +debug: Optimizer: Merge Chained Aggregate Reads +debug: Optimizer: Replace Aggregate Box Ops +debug: Optimizer: Minimize Box Exist Asserts +debug: Optimizer: Constant Reads And Unobserved Writes Elimination +debug: Optimizing subroutine test_cases.structure_methods.contract.GroupedMethods.not_usually_inlined +debug: Optimizer: Perform Subroutine Inlining +debug: Optimizer: Split Parallel Copies +debug: Optimizer: Constant Replacer +debug: Optimizer: Copy Propagation +debug: Optimizer: Elide Itxn Field Calls +debug: Optimizer: Remove Unused Variables +debug: Optimizer: Intrinsic Simplifier +debug: Optimizer: Inner Txn Field Replacer +debug: Optimizer: Replace Compiled References +debug: Optimizer: Simplify Control Ops +debug: Optimizer: Merge Blocks +debug: Optimizer: Remove Linear Jumps +debug: Optimizer: Remove Unreachable Blocks +debug: Optimizer: Repeated Expression Elimination +debug: Optimizer: Encode Decode Pair Elimination +debug: Optimizer: Merge Chained Aggregate Reads +debug: Optimizer: Replace Aggregate Box Ops +debug: Optimizer: Minimize Box Exist Asserts +debug: Optimizer: Constant Reads And Unobserved Writes Elimination +debug: removing unused subroutine test_cases.structure_methods.contract.ARC4TestStruct.return1 +debug: removing unused subroutine test_cases.structure_methods.contract.TestStruct.return1 +debug: removing unused subroutine test_cases.structure_methods.contract.TestNamedTuple.return_value_times +debug: removing unused subroutine test_cases.structure_methods.contract.TestNamedTuple.return1 +debug: removing unused subroutine test_cases.structure_methods.contract.GroupedMethods.always_inlined_not_usually_inlined +debug: removing unused subroutine test_cases.structure_methods.contract.GroupedMethods.usually_inlined +debug: Unused subroutines removed +debug: Begin optimization pass 4/100 +debug: Optimizing subroutine algopy.arc4.ARC4Contract.approval_program +debug: Optimizer: Perform Subroutine Inlining +debug: Optimizer: Split Parallel Copies +debug: Optimizer: Constant Replacer +debug: Optimizer: Copy Propagation +debug: Optimizer: Elide Itxn Field Calls +debug: Optimizer: Remove Unused Variables +debug: Removing unused variable tmp%0#3 +debug: Removing unused variable tmp%5#1 +debug: Removing unused variable tmp%0#4 +debug: Removing unused variable tmp%11#1 +debug: Removing unused variable tmp%13#0 +debug: Removing unused variable tmp%15#0 +debug: Removing unused variable tmp%17#0 +debug: Removing unused variable tmp%19#0 +debug: Removing unused variable tmp%21#0 +debug: Removing unused variable tmp%23#0 +debug: Removing unused variable tmp%0#5 +debug: Removing unused variable tmp%29#0 +debug: Removing unused variable tmp%0#6 +debug: Removing unused variable tmp%31#0 +debug: Optimizer: Intrinsic Simplifier +debug: Optimizer: Inner Txn Field Replacer +debug: Optimizer: Replace Compiled References +debug: Optimizer: Simplify Control Ops +debug: Optimizer: Merge Blocks +debug: Optimizer: Remove Linear Jumps +debug: Optimizer: Remove Unreachable Blocks +debug: Optimizer: Repeated Expression Elimination +debug: Optimizer: Encode Decode Pair Elimination +debug: Optimizer: Merge Chained Aggregate Reads +debug: Optimizer: Replace Aggregate Box Ops +debug: Optimizer: Minimize Box Exist Asserts +debug: Optimizer: Constant Reads And Unobserved Writes Elimination +debug: Optimizing subroutine test_cases.structure_methods.contract.ARC4TestStruct.return_value_times +debug: Optimizer: Perform Subroutine Inlining +debug: Optimizer: Split Parallel Copies +debug: Optimizer: Constant Replacer +debug: Optimizer: Copy Propagation +debug: Optimizer: Elide Itxn Field Calls +debug: Optimizer: Remove Unused Variables +debug: Optimizer: Intrinsic Simplifier +debug: Optimizer: Inner Txn Field Replacer +debug: Optimizer: Replace Compiled References +debug: Optimizer: Simplify Control Ops +debug: Optimizer: Merge Blocks +debug: Optimizer: Remove Linear Jumps +debug: Optimizer: Remove Unreachable Blocks +debug: Optimizer: Repeated Expression Elimination +debug: Optimizer: Encode Decode Pair Elimination +debug: Optimizer: Merge Chained Aggregate Reads +debug: Optimizer: Replace Aggregate Box Ops +debug: Optimizer: Minimize Box Exist Asserts +debug: Optimizer: Constant Reads And Unobserved Writes Elimination +debug: Optimizing subroutine test_cases.structure_methods.contract.TestStruct.return_value_times +debug: Optimizer: Perform Subroutine Inlining +debug: Optimizer: Split Parallel Copies +debug: Optimizer: Constant Replacer +debug: Optimizer: Copy Propagation +debug: Optimizer: Elide Itxn Field Calls +debug: Optimizer: Remove Unused Variables +debug: Optimizer: Intrinsic Simplifier +debug: Optimizer: Inner Txn Field Replacer +debug: Optimizer: Replace Compiled References +debug: Optimizer: Simplify Control Ops +debug: Optimizer: Merge Blocks +debug: Optimizer: Remove Linear Jumps +debug: Optimizer: Remove Unreachable Blocks +debug: Optimizer: Repeated Expression Elimination +debug: Optimizer: Encode Decode Pair Elimination +debug: Optimizer: Merge Chained Aggregate Reads +debug: Optimizer: Replace Aggregate Box Ops +debug: Optimizer: Minimize Box Exist Asserts +debug: Optimizer: Constant Reads And Unobserved Writes Elimination +debug: Optimizing subroutine test_cases.structure_methods.contract.GroupedMethods.never_inlined_usually_inlined +debug: Optimizer: Perform Subroutine Inlining +debug: Optimizer: Split Parallel Copies +debug: Optimizer: Constant Replacer +debug: Optimizer: Copy Propagation +debug: Optimizer: Elide Itxn Field Calls +debug: Optimizer: Remove Unused Variables +debug: Optimizer: Intrinsic Simplifier +debug: Optimizer: Inner Txn Field Replacer +debug: Optimizer: Replace Compiled References +debug: Optimizer: Simplify Control Ops +debug: Optimizer: Merge Blocks +debug: Optimizer: Remove Linear Jumps +debug: Optimizer: Remove Unreachable Blocks +debug: Optimizer: Repeated Expression Elimination +debug: Optimizer: Encode Decode Pair Elimination +debug: Optimizer: Merge Chained Aggregate Reads +debug: Optimizer: Replace Aggregate Box Ops +debug: Optimizer: Minimize Box Exist Asserts +debug: Optimizer: Constant Reads And Unobserved Writes Elimination +debug: Optimizing subroutine test_cases.structure_methods.contract.GroupedMethods.not_usually_inlined +debug: Optimizer: Perform Subroutine Inlining +debug: Optimizer: Split Parallel Copies +debug: Optimizer: Constant Replacer +debug: Optimizer: Copy Propagation +debug: Optimizer: Elide Itxn Field Calls +debug: Optimizer: Remove Unused Variables +debug: Optimizer: Intrinsic Simplifier +debug: Optimizer: Inner Txn Field Replacer +debug: Optimizer: Replace Compiled References +debug: Optimizer: Simplify Control Ops +debug: Optimizer: Merge Blocks +debug: Optimizer: Remove Linear Jumps +debug: Optimizer: Remove Unreachable Blocks +debug: Optimizer: Repeated Expression Elimination +debug: Optimizer: Encode Decode Pair Elimination +debug: Optimizer: Merge Chained Aggregate Reads +debug: Optimizer: Replace Aggregate Box Ops +debug: Optimizer: Minimize Box Exist Asserts +debug: Optimizer: Constant Reads And Unobserved Writes Elimination +debug: Begin optimization pass 5/100 +debug: Optimizing subroutine algopy.arc4.ARC4Contract.approval_program +debug: Optimizer: Perform Subroutine Inlining +debug: Optimizer: Split Parallel Copies +debug: Optimizer: Constant Replacer +debug: Optimizer: Copy Propagation +debug: Optimizer: Elide Itxn Field Calls +debug: Optimizer: Remove Unused Variables +debug: Optimizer: Intrinsic Simplifier +debug: Optimizer: Inner Txn Field Replacer +debug: Optimizer: Replace Compiled References +debug: Optimizer: Simplify Control Ops +debug: Optimizer: Merge Blocks +debug: Optimizer: Remove Linear Jumps +debug: Optimizer: Remove Unreachable Blocks +debug: Optimizer: Repeated Expression Elimination +debug: Optimizer: Encode Decode Pair Elimination +debug: Optimizer: Merge Chained Aggregate Reads +debug: Optimizer: Replace Aggregate Box Ops +debug: Optimizer: Minimize Box Exist Asserts +debug: Optimizer: Constant Reads And Unobserved Writes Elimination +debug: Optimizing subroutine test_cases.structure_methods.contract.ARC4TestStruct.return_value_times +debug: Optimizer: Perform Subroutine Inlining +debug: Optimizer: Split Parallel Copies +debug: Optimizer: Constant Replacer +debug: Optimizer: Copy Propagation +debug: Optimizer: Elide Itxn Field Calls +debug: Optimizer: Remove Unused Variables +debug: Optimizer: Intrinsic Simplifier +debug: Optimizer: Inner Txn Field Replacer +debug: Optimizer: Replace Compiled References +debug: Optimizer: Simplify Control Ops +debug: Optimizer: Merge Blocks +debug: Optimizer: Remove Linear Jumps +debug: Optimizer: Remove Unreachable Blocks +debug: Optimizer: Repeated Expression Elimination +debug: Optimizer: Encode Decode Pair Elimination +debug: Optimizer: Merge Chained Aggregate Reads +debug: Optimizer: Replace Aggregate Box Ops +debug: Optimizer: Minimize Box Exist Asserts +debug: Optimizer: Constant Reads And Unobserved Writes Elimination +debug: Optimizing subroutine test_cases.structure_methods.contract.TestStruct.return_value_times +debug: Optimizer: Perform Subroutine Inlining +debug: Optimizer: Split Parallel Copies +debug: Optimizer: Constant Replacer +debug: Optimizer: Copy Propagation +debug: Optimizer: Elide Itxn Field Calls +debug: Optimizer: Remove Unused Variables +debug: Optimizer: Intrinsic Simplifier +debug: Optimizer: Inner Txn Field Replacer +debug: Optimizer: Replace Compiled References +debug: Optimizer: Simplify Control Ops +debug: Optimizer: Merge Blocks +debug: Optimizer: Remove Linear Jumps +debug: Optimizer: Remove Unreachable Blocks +debug: Optimizer: Repeated Expression Elimination +debug: Optimizer: Encode Decode Pair Elimination +debug: Optimizer: Merge Chained Aggregate Reads +debug: Optimizer: Replace Aggregate Box Ops +debug: Optimizer: Minimize Box Exist Asserts +debug: Optimizer: Constant Reads And Unobserved Writes Elimination +debug: Optimizing subroutine test_cases.structure_methods.contract.GroupedMethods.never_inlined_usually_inlined +debug: Optimizer: Perform Subroutine Inlining +debug: Optimizer: Split Parallel Copies +debug: Optimizer: Constant Replacer +debug: Optimizer: Copy Propagation +debug: Optimizer: Elide Itxn Field Calls +debug: Optimizer: Remove Unused Variables +debug: Optimizer: Intrinsic Simplifier +debug: Optimizer: Inner Txn Field Replacer +debug: Optimizer: Replace Compiled References +debug: Optimizer: Simplify Control Ops +debug: Optimizer: Merge Blocks +debug: Optimizer: Remove Linear Jumps +debug: Optimizer: Remove Unreachable Blocks +debug: Optimizer: Repeated Expression Elimination +debug: Optimizer: Encode Decode Pair Elimination +debug: Optimizer: Merge Chained Aggregate Reads +debug: Optimizer: Replace Aggregate Box Ops +debug: Optimizer: Minimize Box Exist Asserts +debug: Optimizer: Constant Reads And Unobserved Writes Elimination +debug: Optimizing subroutine test_cases.structure_methods.contract.GroupedMethods.not_usually_inlined +debug: Optimizer: Perform Subroutine Inlining +debug: Optimizer: Split Parallel Copies +debug: Optimizer: Constant Replacer +debug: Optimizer: Copy Propagation +debug: Optimizer: Elide Itxn Field Calls +debug: Optimizer: Remove Unused Variables +debug: Optimizer: Intrinsic Simplifier +debug: Optimizer: Inner Txn Field Replacer +debug: Optimizer: Replace Compiled References +debug: Optimizer: Simplify Control Ops +debug: Optimizer: Merge Blocks +debug: Optimizer: Remove Linear Jumps +debug: Optimizer: Remove Unreachable Blocks +debug: Optimizer: Repeated Expression Elimination +debug: Optimizer: Encode Decode Pair Elimination +debug: Optimizer: Merge Chained Aggregate Reads +debug: Optimizer: Replace Aggregate Box Ops +debug: Optimizer: Minimize Box Exist Asserts +debug: Optimizer: Constant Reads And Unobserved Writes Elimination +debug: No optimizations performed in pass 5, ending loop +debug: optimizing clear program of test_cases.structure_methods.contract.TestContract at level 2 +debug: Begin optimization pass 1/100 +debug: Optimizing subroutine algopy.arc4.ARC4Contract.clear_state_program +debug: Optimizer: Perform Subroutine Inlining +debug: Optimizer: Split Parallel Copies +debug: Optimizer: Constant Replacer +debug: Optimizer: Copy Propagation +debug: Optimizer: Elide Itxn Field Calls +debug: Optimizer: Remove Unused Variables +debug: Optimizer: Intrinsic Simplifier +debug: Optimizer: Inner Txn Field Replacer +debug: Optimizer: Replace Compiled References +debug: Optimizer: Simplify Control Ops +debug: Optimizer: Merge Blocks +debug: Optimizer: Remove Linear Jumps +debug: Optimizer: Remove Unreachable Blocks +debug: Optimizer: Repeated Expression Elimination +debug: Optimizer: Encode Decode Pair Elimination +debug: Optimizer: Merge Chained Aggregate Reads +debug: Optimizer: Replace Aggregate Box Ops +debug: Optimizer: Minimize Box Exist Asserts +debug: Optimizer: Constant Reads And Unobserved Writes Elimination +debug: No optimizations performed in pass 1, ending loop +debug: lowering array IR nodes in approval program of test_cases.structure_methods.contract.TestContract +debug: lowering array IR nodes in clear program of test_cases.structure_methods.contract.TestContract +debug: optimizing approval program of test_cases.structure_methods.contract.TestContract at level 2 +debug: Begin optimization pass 1/100 +debug: marking simple function test_cases.structure_methods.contract.ARC4TestStruct.return_value_times for inlining (complexity=4 <= threshold=4) +debug: marking simple function test_cases.structure_methods.contract.TestStruct.return_value_times for inlining (complexity=4 <= threshold=4) +debug: Optimizing subroutine algopy.arc4.ARC4Contract.approval_program +debug: Optimizer: Perform Subroutine Inlining +structure_methods/contract.py:73:30 debug: inlining call to test_cases.structure_methods.contract.ARC4TestStruct.return_value_times in algopy.arc4.ARC4Contract.approval_program +structure_methods/contract.py:74:30 debug: inlining call to test_cases.structure_methods.contract.TestStruct.return_value_times in algopy.arc4.ARC4Contract.approval_program +structure_methods/contract.py:78:30 debug: inlining call to test_cases.structure_methods.contract.ARC4TestStruct.return_value_times in algopy.arc4.ARC4Contract.approval_program +structure_methods/contract.py:81:30 debug: inlining call to test_cases.structure_methods.contract.TestStruct.return_value_times in algopy.arc4.ARC4Contract.approval_program +debug: Optimizer: Split Parallel Copies +debug: Optimizer: Constant Replacer +debug: Optimizer: Copy Propagation +debug: Found equivalence set: aggregate%head%0#0, aggregate%as_Encoded(uint64)%0#0, tmp%0#2, self#0, return_value_times%1#0, self#2, return_value_times%5#0 +debug: selected self#0 from equivalence set +debug: Found equivalence set: aggregate%extract%0#0, tuple_item%0#0 +debug: selected aggregate%extract%0#0 from equivalence set +debug: Found equivalence set: tmp%1#3, return_value_times%0#0 +debug: selected tmp%1#3 from equivalence set +debug: Found equivalence set: aggregate%val_as_bytes%0#0, aggregate%as_Encoded(uint64)%1#0 +debug: selected aggregate%val_as_bytes%0#0 from equivalence set +debug: Found equivalence set: aggregate%head%1#0, aggregate%as_Encoded(uint64)%2#0, tmp%2#1, self#1, return_value_times%3#0, self#3, return_value_times%7#0 +debug: selected self#1 from equivalence set +debug: Found equivalence set: aggregate%extract%0#1, tuple_item%0#1 +debug: selected aggregate%extract%0#1 from equivalence set +debug: Found equivalence set: tmp%0#9, return_value_times%2#0 +debug: selected tmp%0#9 from equivalence set +debug: Found equivalence set: aggregate%extract%0#2, tuple_item%0#2 +debug: selected aggregate%extract%0#2 from equivalence set +debug: Found equivalence set: tmp%1#4, return_value_times%4#0 +debug: selected tmp%1#4 from equivalence set +debug: Found equivalence set: aggregate%extract%0#3, tuple_item%0#3 +debug: selected aggregate%extract%0#3 from equivalence set +debug: Found equivalence set: tmp%0#11, return_value_times%6#0 +debug: selected tmp%0#11 from equivalence set +debug: Found equivalence set: aggregate%val_as_bytes%1#0, aggregate%as_Encoded(uint64)%3#0, tmp%0#7 +debug: selected aggregate%val_as_bytes%1#0 from equivalence set +debug: Found equivalence set: aggregate%head%2#0, aggregate%as_Encoded(uint64)%4#0, tmp%1#2 +debug: selected aggregate%head%2#0 from equivalence set +debug: Copy propagation made 15 modifications +debug: Optimizer: Elide Itxn Field Calls +debug: Optimizer: Remove Unused Variables +debug: Removing unused variable times#0 +debug: Removing unused variable times#1 +debug: Removing unused variable times#2 +debug: Removing unused variable times#3 +debug: Optimizer: Intrinsic Simplifier +debug: Simplified (concat 0x 0x0000000000000009) to 0x0000000000000009 +debug: Simplified (extract3 0x0000000000000009 0u 8u) to 0x0000000000000009 +debug: Simplified (btoi 0x0000000000000009) to 9u +debug: Simplified (* 9u 2u) to 18u +debug: Simplified (== 18u 18u) to 1u +debug: Simplified (concat 0x aggregate%val_as_bytes%0#0) to aggregate%val_as_bytes%0#0 +debug: Simplified (extract3 aggregate%val_as_bytes%0#0 0u 8u) to 0x0000000000000009 +debug: Simplified (btoi 0x0000000000000009) to 9u +debug: Simplified (* 9u 2u) to 18u +debug: Simplified (== 18u 18u) to 1u +debug: Simplified (extract3 0x0000000000000009 0u 8u) to 0x0000000000000009 +debug: Simplified (btoi 0x0000000000000009) to 9u +debug: Simplified (* 9u 2u) to 18u +debug: Simplified (== 18u 18u) to 1u +debug: Simplified (extract3 aggregate%val_as_bytes%0#0 0u 8u) to 0x0000000000000009 +debug: Simplified (btoi 0x0000000000000009) to 9u +debug: Simplified (* 9u 2u) to 18u +debug: Simplified (== 18u 18u) to 1u +debug: Simplified (concat 0x aggregate%val_as_bytes%1#0) to aggregate%val_as_bytes%1#0 +debug: Simplified (concat method "ARC4TestStruct(uint64)" aggregate%val_as_bytes%1#0) to 0xed3267e80000000000000002 +debug: Optimizer: Inner Txn Field Replacer +debug: Optimizer: Replace Compiled References +debug: Optimizer: Simplify Control Ops +debug: Optimizer: Merge Blocks +debug: Replaced predecessor block@6 with block@3 in block@7 +debug: Merged linear block@6 into block@3 +debug: Replaced predecessor block@7 with block@3 in block@8 +debug: Merged linear block@7 into block@3 +debug: Replaced predecessor block@8 with block@3 in block@9 +debug: Merged linear block@8 into block@3 +debug: Replaced predecessor block@9 with block@3 in block@10 +debug: Merged linear block@9 into block@3 +debug: Replaced predecessor block@10 with block@3 in block@11 +debug: Merged linear block@10 into block@3 +debug: Replaced predecessor block@11 with block@3 in block@12 +debug: Merged linear block@11 into block@3 +debug: Replaced predecessor block@12 with block@3 in block@13 +debug: Merged linear block@12 into block@3 +debug: Merged linear block@13 into block@3 +debug: Optimizer: Remove Linear Jumps +debug: Optimizer: Remove Unreachable Blocks +debug: Optimizer: Repeated Expression Elimination +debug: Optimizer: Encode Decode Pair Elimination +debug: Optimizer: Merge Chained Aggregate Reads +debug: Optimizer: Replace Aggregate Box Ops +debug: Optimizer: Minimize Box Exist Asserts +debug: Optimizer: Constant Reads And Unobserved Writes Elimination +debug: Optimizing subroutine test_cases.structure_methods.contract.ARC4TestStruct.return_value_times +debug: Optimizer: Perform Subroutine Inlining +debug: Optimizer: Split Parallel Copies +debug: Optimizer: Constant Replacer +debug: Optimizer: Copy Propagation +debug: Found equivalence set: aggregate%extract%0#0, tuple_item%0#0 +debug: selected aggregate%extract%0#0 from equivalence set +debug: Copy propagation made 1 modifications +debug: Optimizer: Elide Itxn Field Calls +debug: Optimizer: Remove Unused Variables +debug: Optimizer: Intrinsic Simplifier +debug: Simplified (btoi aggregate%extract%0#0) to (extract_uint64 self#0 0u) +debug: Simplified (extract3 self#0 0u 8u) to ((extract 0 8) self#0) +debug: Optimizer: Inner Txn Field Replacer +debug: Optimizer: Replace Compiled References +debug: Optimizer: Simplify Control Ops +debug: Optimizer: Merge Blocks +debug: Optimizer: Remove Linear Jumps +debug: Optimizer: Remove Unreachable Blocks +debug: Optimizer: Repeated Expression Elimination +debug: Optimizer: Encode Decode Pair Elimination +debug: Optimizer: Merge Chained Aggregate Reads +debug: Optimizer: Replace Aggregate Box Ops +debug: Optimizer: Minimize Box Exist Asserts +debug: Optimizer: Constant Reads And Unobserved Writes Elimination +debug: Optimizing subroutine test_cases.structure_methods.contract.TestStruct.return_value_times +debug: Optimizer: Perform Subroutine Inlining +debug: Optimizer: Split Parallel Copies +debug: Optimizer: Constant Replacer +debug: Optimizer: Copy Propagation +debug: Found equivalence set: aggregate%extract%0#0, tuple_item%0#0 +debug: selected aggregate%extract%0#0 from equivalence set +debug: Copy propagation made 1 modifications +debug: Optimizer: Elide Itxn Field Calls +debug: Optimizer: Remove Unused Variables +debug: Optimizer: Intrinsic Simplifier +debug: Simplified (btoi aggregate%extract%0#0) to (extract_uint64 self#0 0u) +debug: Simplified (extract3 self#0 0u 8u) to ((extract 0 8) self#0) +debug: Optimizer: Inner Txn Field Replacer +debug: Optimizer: Replace Compiled References +debug: Optimizer: Simplify Control Ops +debug: Optimizer: Merge Blocks +debug: Optimizer: Remove Linear Jumps +debug: Optimizer: Remove Unreachable Blocks +debug: Optimizer: Repeated Expression Elimination +debug: Optimizer: Encode Decode Pair Elimination +debug: Optimizer: Merge Chained Aggregate Reads +debug: Optimizer: Replace Aggregate Box Ops +debug: Optimizer: Minimize Box Exist Asserts +debug: Optimizer: Constant Reads And Unobserved Writes Elimination +debug: Optimizing subroutine test_cases.structure_methods.contract.GroupedMethods.never_inlined_usually_inlined +debug: Optimizer: Perform Subroutine Inlining +debug: Optimizer: Split Parallel Copies +debug: Optimizer: Constant Replacer +debug: Optimizer: Copy Propagation +debug: Optimizer: Elide Itxn Field Calls +debug: Optimizer: Remove Unused Variables +debug: Optimizer: Intrinsic Simplifier +debug: Optimizer: Inner Txn Field Replacer +debug: Optimizer: Replace Compiled References +debug: Optimizer: Simplify Control Ops +debug: Optimizer: Merge Blocks +debug: Optimizer: Remove Linear Jumps +debug: Optimizer: Remove Unreachable Blocks +debug: Optimizer: Repeated Expression Elimination +debug: Optimizer: Encode Decode Pair Elimination +debug: Optimizer: Merge Chained Aggregate Reads +debug: Optimizer: Replace Aggregate Box Ops +debug: Optimizer: Minimize Box Exist Asserts +debug: Optimizer: Constant Reads And Unobserved Writes Elimination +debug: Optimizing subroutine test_cases.structure_methods.contract.GroupedMethods.not_usually_inlined +debug: Optimizer: Perform Subroutine Inlining +debug: Optimizer: Split Parallel Copies +debug: Optimizer: Constant Replacer +debug: Optimizer: Copy Propagation +debug: Found equivalence set: aggregate%val_as_bytes%0#0, aggregate%as_Encoded(uint64)%0#0, tmp%0#0 +debug: selected aggregate%val_as_bytes%0#0 from equivalence set +debug: Found equivalence set: aggregate%head%0#0, aggregate%as_Encoded(uint64)%1#0, tmp%1#0 +debug: selected aggregate%head%0#0 from equivalence set +debug: Copy propagation made 2 modifications +debug: Optimizer: Elide Itxn Field Calls +debug: Optimizer: Remove Unused Variables +debug: Optimizer: Intrinsic Simplifier +debug: Simplified (concat 0x aggregate%val_as_bytes%0#0) to aggregate%val_as_bytes%0#0 +debug: Optimizer: Inner Txn Field Replacer +debug: Optimizer: Replace Compiled References +debug: Optimizer: Simplify Control Ops +debug: Optimizer: Merge Blocks +debug: Optimizer: Remove Linear Jumps +debug: Optimizer: Remove Unreachable Blocks +debug: Optimizer: Repeated Expression Elimination +debug: Optimizer: Encode Decode Pair Elimination +debug: Optimizer: Merge Chained Aggregate Reads +debug: Optimizer: Replace Aggregate Box Ops +debug: Optimizer: Minimize Box Exist Asserts +debug: Optimizer: Constant Reads And Unobserved Writes Elimination +debug: removing unused subroutine test_cases.structure_methods.contract.ARC4TestStruct.return_value_times +debug: removing unused subroutine test_cases.structure_methods.contract.TestStruct.return_value_times +debug: Unused subroutines removed +debug: Begin optimization pass 2/100 +debug: Optimizing subroutine algopy.arc4.ARC4Contract.approval_program +debug: Optimizer: Perform Subroutine Inlining +debug: Optimizer: Split Parallel Copies +debug: Optimizer: Constant Replacer +debug: Optimizer: Copy Propagation +debug: Found equivalence set: aggregate%val_as_bytes%0#0, self#1 +debug: selected self#1 from equivalence set +debug: Found equivalence set: aggregate%val_as_bytes%1#0, aggregate%head%2#0 +debug: selected aggregate%val_as_bytes%1#0 from equivalence set +debug: Copy propagation made 1 modifications +debug: Optimizer: Elide Itxn Field Calls +debug: Optimizer: Remove Unused Variables +debug: Removing unused variable self#0 +debug: Removing unused variable aggregate%extract%0#0 +debug: Removing unused variable tmp%0#8 +debug: Removing unused variable tmp%1#3 +debug: Removing unused variable tmp%1#1 +debug: Removing unused variable self#1 +debug: Removing unused variable aggregate%extract%0#1 +debug: Removing unused variable values%0#0 +debug: Removing unused variable tmp%0#9 +debug: Removing unused variable tmp%3#1 +debug: Removing unused variable aggregate%extract%0#2 +debug: Removing unused variable tmp%0#10 +debug: Removing unused variable tmp%1#4 +debug: Removing unused variable tmp%7#1 +debug: Removing unused variable aggregate%extract%0#3 +debug: Removing unused variable values%0#1 +debug: Removing unused variable tmp%0#11 +debug: Removing unused variable tmp%9#1 +debug: Removing unused variable aggregate%val_as_bytes%1#0 +debug: Removing unused variable event%0#0 +debug: Optimizer: Intrinsic Simplifier +debug: Optimizer: Inner Txn Field Replacer +debug: Optimizer: Replace Compiled References +debug: Optimizer: Simplify Control Ops +debug: Optimizer: Merge Blocks +debug: Optimizer: Remove Linear Jumps +debug: Optimizer: Remove Unreachable Blocks +debug: Optimizer: Repeated Expression Elimination +debug: Optimizer: Encode Decode Pair Elimination +debug: Optimizer: Merge Chained Aggregate Reads +debug: Optimizer: Replace Aggregate Box Ops +debug: Optimizer: Minimize Box Exist Asserts +debug: Optimizer: Constant Reads And Unobserved Writes Elimination +debug: Optimizing subroutine test_cases.structure_methods.contract.GroupedMethods.never_inlined_usually_inlined +debug: Optimizer: Perform Subroutine Inlining +debug: Optimizer: Split Parallel Copies +debug: Optimizer: Constant Replacer +debug: Optimizer: Copy Propagation +debug: Optimizer: Elide Itxn Field Calls +debug: Optimizer: Remove Unused Variables +debug: Optimizer: Intrinsic Simplifier +debug: Optimizer: Inner Txn Field Replacer +debug: Optimizer: Replace Compiled References +debug: Optimizer: Simplify Control Ops +debug: Optimizer: Merge Blocks +debug: Optimizer: Remove Linear Jumps +debug: Optimizer: Remove Unreachable Blocks +debug: Optimizer: Repeated Expression Elimination +debug: Optimizer: Encode Decode Pair Elimination +debug: Optimizer: Merge Chained Aggregate Reads +debug: Optimizer: Replace Aggregate Box Ops +debug: Optimizer: Minimize Box Exist Asserts +debug: Optimizer: Constant Reads And Unobserved Writes Elimination +debug: Optimizing subroutine test_cases.structure_methods.contract.GroupedMethods.not_usually_inlined +debug: Optimizer: Perform Subroutine Inlining +debug: Optimizer: Split Parallel Copies +debug: Optimizer: Constant Replacer +debug: Optimizer: Copy Propagation +debug: Found equivalence set: aggregate%val_as_bytes%0#0, aggregate%head%0#0 +debug: selected aggregate%val_as_bytes%0#0 from equivalence set +debug: Optimizer: Elide Itxn Field Calls +debug: Optimizer: Remove Unused Variables +debug: Optimizer: Intrinsic Simplifier +debug: Optimizer: Inner Txn Field Replacer +debug: Optimizer: Replace Compiled References +debug: Optimizer: Simplify Control Ops +debug: Optimizer: Merge Blocks +debug: Optimizer: Remove Linear Jumps +debug: Optimizer: Remove Unreachable Blocks +debug: Optimizer: Repeated Expression Elimination +debug: Optimizer: Encode Decode Pair Elimination +debug: Optimizer: Merge Chained Aggregate Reads +debug: Optimizer: Replace Aggregate Box Ops +debug: Optimizer: Minimize Box Exist Asserts +debug: Optimizer: Constant Reads And Unobserved Writes Elimination +debug: Begin optimization pass 3/100 +debug: Optimizing subroutine algopy.arc4.ARC4Contract.approval_program +debug: Optimizer: Perform Subroutine Inlining +debug: Optimizer: Split Parallel Copies +debug: Optimizer: Constant Replacer +debug: Optimizer: Copy Propagation +debug: Optimizer: Elide Itxn Field Calls +debug: Optimizer: Remove Unused Variables +debug: Optimizer: Intrinsic Simplifier +debug: Optimizer: Inner Txn Field Replacer +debug: Optimizer: Replace Compiled References +debug: Optimizer: Simplify Control Ops +debug: Optimizer: Merge Blocks +debug: Optimizer: Remove Linear Jumps +debug: Optimizer: Remove Unreachable Blocks +debug: Optimizer: Repeated Expression Elimination +debug: Optimizer: Encode Decode Pair Elimination +debug: Optimizer: Merge Chained Aggregate Reads +debug: Optimizer: Replace Aggregate Box Ops +debug: Optimizer: Minimize Box Exist Asserts +debug: Optimizer: Constant Reads And Unobserved Writes Elimination +debug: Optimizing subroutine test_cases.structure_methods.contract.GroupedMethods.never_inlined_usually_inlined +debug: Optimizer: Perform Subroutine Inlining +debug: Optimizer: Split Parallel Copies +debug: Optimizer: Constant Replacer +debug: Optimizer: Copy Propagation +debug: Optimizer: Elide Itxn Field Calls +debug: Optimizer: Remove Unused Variables +debug: Optimizer: Intrinsic Simplifier +debug: Optimizer: Inner Txn Field Replacer +debug: Optimizer: Replace Compiled References +debug: Optimizer: Simplify Control Ops +debug: Optimizer: Merge Blocks +debug: Optimizer: Remove Linear Jumps +debug: Optimizer: Remove Unreachable Blocks +debug: Optimizer: Repeated Expression Elimination +debug: Optimizer: Encode Decode Pair Elimination +debug: Optimizer: Merge Chained Aggregate Reads +debug: Optimizer: Replace Aggregate Box Ops +debug: Optimizer: Minimize Box Exist Asserts +debug: Optimizer: Constant Reads And Unobserved Writes Elimination +debug: Optimizing subroutine test_cases.structure_methods.contract.GroupedMethods.not_usually_inlined +debug: Optimizer: Perform Subroutine Inlining +debug: Optimizer: Split Parallel Copies +debug: Optimizer: Constant Replacer +debug: Optimizer: Copy Propagation +debug: Optimizer: Elide Itxn Field Calls +debug: Optimizer: Remove Unused Variables +debug: Optimizer: Intrinsic Simplifier +debug: Optimizer: Inner Txn Field Replacer +debug: Optimizer: Replace Compiled References +debug: Optimizer: Simplify Control Ops +debug: Optimizer: Merge Blocks +debug: Optimizer: Remove Linear Jumps +debug: Optimizer: Remove Unreachable Blocks +debug: Optimizer: Repeated Expression Elimination +debug: Optimizer: Encode Decode Pair Elimination +debug: Optimizer: Merge Chained Aggregate Reads +debug: Optimizer: Replace Aggregate Box Ops +debug: Optimizer: Minimize Box Exist Asserts +debug: Optimizer: Constant Reads And Unobserved Writes Elimination +debug: No optimizations performed in pass 3, ending loop +debug: optimizing clear program of test_cases.structure_methods.contract.TestContract at level 2 +debug: Begin optimization pass 1/100 +debug: Optimizing subroutine algopy.arc4.ARC4Contract.clear_state_program +debug: Optimizer: Perform Subroutine Inlining +debug: Optimizer: Split Parallel Copies +debug: Optimizer: Constant Replacer +debug: Optimizer: Copy Propagation +debug: Optimizer: Elide Itxn Field Calls +debug: Optimizer: Remove Unused Variables +debug: Optimizer: Intrinsic Simplifier +debug: Optimizer: Inner Txn Field Replacer +debug: Optimizer: Replace Compiled References +debug: Optimizer: Simplify Control Ops +debug: Optimizer: Merge Blocks +debug: Optimizer: Remove Linear Jumps +debug: Optimizer: Remove Unreachable Blocks +debug: Optimizer: Repeated Expression Elimination +debug: Optimizer: Encode Decode Pair Elimination +debug: Optimizer: Merge Chained Aggregate Reads +debug: Optimizer: Replace Aggregate Box Ops +debug: Optimizer: Minimize Box Exist Asserts +debug: Optimizer: Constant Reads And Unobserved Writes Elimination +debug: No optimizations performed in pass 1, ending loop +debug: removing local static slots in approval program of test_cases.structure_methods.contract.TestContract +debug: auto reserving slots in algopy.arc4.ARC4Contract.approval_program, [] +structure_methods/contract.py:40:6 debug: auto reserving slots in test_cases.structure_methods.contract.GroupedMethods.never_inlined_usually_inlined, [] +structure_methods/contract.py:58:5 debug: auto reserving slots in test_cases.structure_methods.contract.GroupedMethods.not_usually_inlined, [] +debug: Slot allocation not required +debug: removing local static slots in clear program of test_cases.structure_methods.contract.TestContract +debug: auto reserving slots in algopy.arc4.ARC4Contract.clear_state_program, [] +debug: Slot allocation not required +debug: Performing SSA IR destructuring for algopy.arc4.ARC4Contract.approval_program +debug: Converting to CSSA +debug: Removing Phi nodes +debug: Coalescing local variables in algopy.arc4.ARC4Contract.approval_program using strategy 'root_operand' +debug: Coalescing resulted in 0 replacement/s +debug: Sequentializing parallel copies in algopy.arc4.ARC4Contract.approval_program +debug: Performing post-SSA optimizations at level 2 +debug: Performing SSA IR destructuring for test_cases.structure_methods.contract.GroupedMethods.never_inlined_usually_inlined +debug: Converting to CSSA +debug: Removing Phi nodes +debug: Coalescing local variables in test_cases.structure_methods.contract.GroupedMethods.never_inlined_usually_inlined using strategy 'root_operand' +debug: Coalescing resulted in 0 replacement/s +debug: Sequentializing parallel copies in test_cases.structure_methods.contract.GroupedMethods.never_inlined_usually_inlined +debug: Performing post-SSA optimizations at level 2 +debug: Performing SSA IR destructuring for test_cases.structure_methods.contract.GroupedMethods.not_usually_inlined +debug: Converting to CSSA +debug: Removing Phi nodes +debug: Coalescing local variables in test_cases.structure_methods.contract.GroupedMethods.not_usually_inlined using strategy 'root_operand' +debug: Coalescing resulted in 0 replacement/s +debug: Sequentializing parallel copies in test_cases.structure_methods.contract.GroupedMethods.not_usually_inlined +debug: Performing post-SSA optimizations at level 2 +debug: Output IR to structure_methods/out_O2/TestContract.ir/TestContract.approval.400.destructured.ir +debug: Performing SSA IR destructuring for algopy.arc4.ARC4Contract.clear_state_program +debug: Converting to CSSA +debug: Removing Phi nodes +debug: Coalescing local variables in algopy.arc4.ARC4Contract.clear_state_program using strategy 'root_operand' +debug: Coalescing resulted in 0 replacement/s +debug: Sequentializing parallel copies in algopy.arc4.ARC4Contract.clear_state_program +debug: Performing post-SSA optimizations at level 2 +debug: Output IR to structure_methods/out_O2/TestContract.ir/TestContract.clear.400.destructured.ir +debug: Inserted main_block@0.ops[1]: 'l-store-copy tmp%0#1 0' +debug: Replaced main_block@0.ops[3]: 'v-load tmp%0#1' with 'l-load tmp%0#1' +debug: Inserted main_abi_routing@2.ops[1]: 'l-store-copy tmp%2#0 0' +debug: Replaced main_abi_routing@2.ops[4]: 'v-load tmp%2#0' with 'l-load tmp%2#0' +debug: Inserted main_test_route@3.ops[1]: 'l-store-copy tmp%3#0 0' +debug: Replaced main_test_route@3.ops[3]: 'v-load tmp%3#0' with 'l-load tmp%3#0' +debug: Inserted main_test_route@3.ops[11]: 'l-store-copy tmp%7#0 0' +debug: Replaced main_test_route@3.ops[13]: 'v-load tmp%7#0' with 'l-load tmp%7#0' +debug: Inserted main_test_route@3.ops[21]: 'l-store-copy tmp%25#0 0' +debug: Replaced main_test_route@3.ops[23]: 'v-load tmp%25#0' with 'l-load tmp%25#0' +debug: Inserted main_test_route@3.ops[31]: 'l-store-copy tmp%27#0 0' +debug: Replaced main_test_route@3.ops[33]: 'v-load tmp%27#0' with 'l-load tmp%27#0' +debug: Inserted main_test_route@3.ops[7]: 'l-store-copy tmp%5#0 0' +debug: Replaced main_test_route@3.ops[10]: 'v-load tmp%5#0' with 'l-load tmp%5#0' +debug: Inserted main_test_route@3.ops[18]: 'l-store-copy tmp%24#0 0' +debug: Replaced main_test_route@3.ops[21]: 'v-load tmp%24#0' with 'l-load tmp%24#0' +debug: Inserted main_test_route@3.ops[29]: 'l-store-copy tmp%26#0 0' +debug: Replaced main_test_route@3.ops[32]: 'v-load tmp%26#0' with 'l-load tmp%26#0' +debug: Inserted main_test_route@3.ops[5]: 'l-store-copy tmp%4#0 0' +debug: Replaced main_test_route@3.ops[10]: 'v-load tmp%4#0' with 'l-load tmp%4#0' +debug: Inserted main___algopy_default_create@5.ops[1]: 'l-store-copy tmp%8#0 0' +debug: Replaced main___algopy_default_create@5.ops[3]: 'v-load tmp%8#0' with 'l-load tmp%8#0' +debug: Inserted main___algopy_default_create@5.ops[7]: 'l-store-copy tmp%10#0 0' +debug: Replaced main___algopy_default_create@5.ops[9]: 'v-load tmp%10#0' with 'l-load tmp%10#0' +debug: Inserted main___algopy_default_create@5.ops[15]: 'l-store-copy tmp%12#0 0' +debug: Replaced main___algopy_default_create@5.ops[17]: 'v-load tmp%12#0' with 'l-load tmp%12#0' +debug: Inserted main___algopy_default_create@5.ops[11]: 'l-store-copy tmp%11#0 0' +debug: Replaced main___algopy_default_create@5.ops[14]: 'v-load tmp%11#0' with 'l-load tmp%11#0' +debug: Inserted main___algopy_default_create@5.ops[5]: 'l-store-copy tmp%9#0 0' +debug: Replaced main___algopy_default_create@5.ops[14]: 'v-load tmp%9#0' with 'l-load tmp%9#0' +debug: Inserted never_inlined_usually_inlined_block@0.ops[3]: 'l-store-copy tmp%0#0 0' +debug: Replaced never_inlined_usually_inlined_block@0.ops[5]: 'v-load tmp%0#0' with 'l-load tmp%0#0' +debug: Inserted not_usually_inlined_block@0.ops[6]: 'l-store-copy event%0#0 0' +debug: Replaced not_usually_inlined_block@0.ops[8]: 'v-load event%0#0' with 'l-load event%0#0' +debug: Inserted not_usually_inlined_block@0.ops[2]: 'l-store-copy aggregate%val_as_bytes%0#0 0' +debug: Replaced not_usually_inlined_block@0.ops[5]: 'v-load aggregate%val_as_bytes%0#0' with 'l-load aggregate%val_as_bytes%0#0' +debug: Inserted not_usually_inlined_block@0.ops[10]: 'l-store-copy event%0#0 0' +debug: Replaced not_usually_inlined_block@0.ops[12]: 'v-load event%0#0' with 'l-load event%0#0' +debug: Inserted not_usually_inlined_block@0.ops[13]: 'l-store-copy event%0#0 0' +debug: Replaced not_usually_inlined_block@0.ops[15]: 'v-load event%0#0' with 'l-load event%0#0' +debug: Inserted not_usually_inlined_block@0.ops[16]: 'l-store-copy event%0#0 0' +debug: Replaced not_usually_inlined_block@0.ops[18]: 'v-load event%0#0' with 'l-load event%0#0' +debug: Inserted not_usually_inlined_block@0.ops[19]: 'l-store-copy event%0#0 0' +debug: Replaced not_usually_inlined_block@0.ops[21]: 'v-load event%0#0' with 'l-load event%0#0' +debug: Inserted not_usually_inlined_block@0.ops[22]: 'l-store-copy event%0#0 0' +debug: Replaced not_usually_inlined_block@0.ops[24]: 'v-load event%0#0' with 'l-load event%0#0' +debug: Inserted not_usually_inlined_block@0.ops[25]: 'l-store-copy event%0#0 0' +debug: Replaced not_usually_inlined_block@0.ops[27]: 'v-load event%0#0' with 'l-load event%0#0' +debug: Inserted not_usually_inlined_block@0.ops[28]: 'l-store-copy event%0#0 0' +debug: Replaced not_usually_inlined_block@0.ops[30]: 'v-load event%0#0' with 'l-load event%0#0' +debug: Found 2 edge set/s for algopy.arc4.ARC4Contract.approval_program +debug: optimizing TEAL subroutine ops algopy.arc4.ARC4Contract.approval_program() -> uint64: +structure_methods/contract.py:40:6 debug: optimizing TEAL subroutine ops test_cases.structure_methods.contract.GroupedMethods.never_inlined_usually_inlined(v: uint64) -> uint64: +structure_methods/contract.py:58:5 debug: optimizing TEAL subroutine ops test_cases.structure_methods.contract.GroupedMethods.not_usually_inlined(v: uint64) -> void: +debug: optimizing TEAL subroutine blocks algopy.arc4.ARC4Contract.approval_program() -> uint64: +debug: inlining single reference block main_block@0 into main +debug: inlining single reference block main_abi_routing@2 into main +debug: inlining single reference block main_switch_case_next@4 into main +structure_methods/contract.py:40:6 debug: optimizing TEAL subroutine blocks test_cases.structure_methods.contract.GroupedMethods.never_inlined_usually_inlined(v: uint64) -> uint64: +debug: inlining single reference block never_inlined_usually_inlined_block@0 into never_inlined_usually_inlined +structure_methods/contract.py:58:5 debug: optimizing TEAL subroutine blocks test_cases.structure_methods.contract.GroupedMethods.not_usually_inlined(v: uint64) -> void: +debug: inlining single reference block not_usually_inlined_block@0 into not_usually_inlined +debug: optimizing TEAL subroutine ops algopy.arc4.ARC4Contract.clear_state_program() -> uint64: +debug: optimizing TEAL subroutine blocks algopy.arc4.ARC4Contract.clear_state_program() -> uint64: +debug: inlining single reference block main_block@0 into main +info: Writing structure_methods/out_O2/TestContract.approval.teal +info: Writing structure_methods/out_O2/TestContract.clear.teal +info: Writing structure_methods/out_O2/TestContract.approval.bin +info: Writing structure_methods/out_O2/TestContract.clear.bin +info: Writing structure_methods/out_O2/TestContract.approval.stats.txt +info: Writing structure_methods/out_O2/TestContract.clear.stats.txt +info: Writing structure_methods/out_O2/TestContract.approval.puya.map +info: Writing structure_methods/out_O2/TestContract.clear.puya.map \ No newline at end of file diff --git a/test_cases/structure_methods/puya_unoptimized.log b/test_cases/structure_methods/puya_unoptimized.log new file mode 100644 index 0000000000..308d347c40 --- /dev/null +++ b/test_cases/structure_methods/puya_unoptimized.log @@ -0,0 +1,1670 @@ +debug: PuyaPyOptions(output_teal=True, output_source_map=True, output_arc32=False, output_arc56=False, output_ssa_ir=False, output_optimization_ir=False, output_destructured_ir=True, output_memory_ir=False, output_bytecode=True, output_teal_intermediates=False, output_op_statistics=True, debug_level=1, optimization_level=0, target_avm_version=11, cli_template_definitions={}, template_vars_prefix='TMPL_', locals_coalescing_strategy=, optimizations_override=immutabledict({}), expand_all_bytes=False, validate_abi_args=True, validate_abi_return=True, paths=['structure_methods'], resource_encoding='value', output_awst=False, output_awst_json=False, output_source_annotations_json=False, output_client=False, log_level=) +debug: Building IR for function _puya_lib.util.ensure_budget +debug: Sealing block@0 +debug: Terminated block@0 +debug: Looking for 'required_budget_with_buffer' in an unsealed block creating an incomplete Phi: block@1 +debug: Created Phi assignment: let required_budget_with_buffer#1: uint64 = undefined while trying to resolve 'required_budget_with_buffer' in block@1 +debug: Terminated block@1 +debug: Sealing block@2 +debug: Looking for 'fee_source' in an unsealed block creating an incomplete Phi: block@1 +debug: Created Phi assignment: let fee_source#1: uint64 = undefined while trying to resolve 'fee_source' in block@1 +debug: Terminated block@2 +debug: Terminated block@3 +debug: Terminated block@4 +debug: Sealing block@5 +debug: Terminated block@5 +debug: Sealing block@1 +debug: Added required_budget_with_buffer#0 to Phi node: let required_budget_with_buffer#1: uint64 = φ(required_budget_with_buffer#0 <- block@0) in block@0 +debug: Created Phi assignment: let required_budget_with_buffer#2: uint64 = undefined while trying to resolve 'required_budget_with_buffer' in block@5 +debug: Added required_budget_with_buffer#1 to Phi node: let required_budget_with_buffer#2: uint64 = φ(required_budget_with_buffer#1 <- block@2) in block@2 +debug: Looking for 'required_budget_with_buffer' in an unsealed block creating an incomplete Phi: block@3 +debug: Created Phi assignment: let required_budget_with_buffer#3: uint64 = undefined while trying to resolve 'required_budget_with_buffer' in block@3 +debug: Added required_budget_with_buffer#3 to Phi node: let required_budget_with_buffer#2: uint64 = φ(required_budget_with_buffer#1 <- block@2, required_budget_with_buffer#3 <- block@3) in block@3 +debug: Looking for 'required_budget_with_buffer' in an unsealed block creating an incomplete Phi: block@4 +debug: Created Phi assignment: let required_budget_with_buffer#4: uint64 = undefined while trying to resolve 'required_budget_with_buffer' in block@4 +debug: Added required_budget_with_buffer#4 to Phi node: let required_budget_with_buffer#2: uint64 = φ(required_budget_with_buffer#1 <- block@2, required_budget_with_buffer#3 <- block@3, required_budget_with_buffer#4 <- block@4) in block@4 +debug: Added required_budget_with_buffer#2 to Phi node: let required_budget_with_buffer#1: uint64 = φ(required_budget_with_buffer#0 <- block@0, required_budget_with_buffer#2 <- block@5) in block@5 +debug: Added fee_source#0 to Phi node: let fee_source#1: uint64 = φ(fee_source#0 <- block@0) in block@0 +debug: Created Phi assignment: let fee_source#2: uint64 = undefined while trying to resolve 'fee_source' in block@5 +debug: Added fee_source#1 to Phi node: let fee_source#2: uint64 = φ(fee_source#1 <- block@2) in block@2 +debug: Looking for 'fee_source' in an unsealed block creating an incomplete Phi: block@3 +debug: Created Phi assignment: let fee_source#3: uint64 = undefined while trying to resolve 'fee_source' in block@3 +debug: Added fee_source#3 to Phi node: let fee_source#2: uint64 = φ(fee_source#1 <- block@2, fee_source#3 <- block@3) in block@3 +debug: Looking for 'fee_source' in an unsealed block creating an incomplete Phi: block@4 +debug: Created Phi assignment: let fee_source#4: uint64 = undefined while trying to resolve 'fee_source' in block@4 +debug: Added fee_source#4 to Phi node: let fee_source#2: uint64 = φ(fee_source#1 <- block@2, fee_source#3 <- block@3, fee_source#4 <- block@4) in block@4 +debug: Added fee_source#2 to Phi node: let fee_source#1: uint64 = φ(fee_source#0 <- block@0, fee_source#2 <- block@5) in block@5 +debug: Sealing block@6 +debug: Terminated block@6 +debug: Sealing block@3 +debug: Added required_budget_with_buffer#1 to Phi node: let required_budget_with_buffer#3: uint64 = φ(required_budget_with_buffer#1 <- block@2) in block@2 +debug: Replacing trivial Phi node: let required_budget_with_buffer#3: uint64 = φ(required_budget_with_buffer#1 <- block@2) (required_budget_with_buffer#3) with required_budget_with_buffer#1 +debug: Deleting Phi assignment: let required_budget_with_buffer#3: uint64 = φ(required_budget_with_buffer#1 <- block@2) +debug: Replaced trivial Phi node: let required_budget_with_buffer#3: uint64 = φ(required_budget_with_buffer#1 <- block@2) (required_budget_with_buffer#3) with required_budget_with_buffer#1 in current definition for 1 blocks +debug: Added fee_source#1 to Phi node: let fee_source#3: uint64 = φ(fee_source#1 <- block@2) in block@2 +debug: Replacing trivial Phi node: let fee_source#3: uint64 = φ(fee_source#1 <- block@2) (fee_source#3) with fee_source#1 +debug: Deleting Phi assignment: let fee_source#3: uint64 = φ(fee_source#1 <- block@2) +debug: Replaced trivial Phi node: let fee_source#3: uint64 = φ(fee_source#1 <- block@2) (fee_source#3) with fee_source#1 in current definition for 1 blocks +debug: Sealing block@4 +debug: Added required_budget_with_buffer#1 to Phi node: let required_budget_with_buffer#4: uint64 = φ(required_budget_with_buffer#1 <- block@2) in block@2 +debug: Replacing trivial Phi node: let required_budget_with_buffer#4: uint64 = φ(required_budget_with_buffer#1 <- block@2) (required_budget_with_buffer#4) with required_budget_with_buffer#1 +debug: Deleting Phi assignment: let required_budget_with_buffer#4: uint64 = φ(required_budget_with_buffer#1 <- block@2) +debug: Replacing trivial Phi node: let required_budget_with_buffer#2: uint64 = φ(required_budget_with_buffer#1 <- block@2, required_budget_with_buffer#1 <- block@3, required_budget_with_buffer#1 <- block@4) (required_budget_with_buffer#2) with required_budget_with_buffer#1 +debug: Deleting Phi assignment: let required_budget_with_buffer#2: uint64 = φ(required_budget_with_buffer#1 <- block@2, required_budget_with_buffer#1 <- block@3, required_budget_with_buffer#1 <- block@4) +debug: Replacing trivial Phi node: let required_budget_with_buffer#1: uint64 = φ(required_budget_with_buffer#0 <- block@0, required_budget_with_buffer#1 <- block@5) (required_budget_with_buffer#1) with required_budget_with_buffer#0 +debug: Deleting Phi assignment: let required_budget_with_buffer#1: uint64 = φ(required_budget_with_buffer#0 <- block@0, required_budget_with_buffer#1 <- block@5) +debug: Replaced trivial Phi node: let required_budget_with_buffer#4: uint64 = φ(required_budget_with_buffer#1 <- block@2) (required_budget_with_buffer#4) with required_budget_with_buffer#1 in current definition for 1 blocks +debug: Replaced trivial Phi node: let required_budget_with_buffer#2: uint64 = φ(required_budget_with_buffer#1 <- block@2, required_budget_with_buffer#1 <- block@3, required_budget_with_buffer#1 <- block@4) (required_budget_with_buffer#2) with required_budget_with_buffer#1 in current definition for 1 blocks +debug: Replaced trivial Phi node: let required_budget_with_buffer#1: uint64 = φ(required_budget_with_buffer#0 <- block@0, required_budget_with_buffer#1 <- block@5) (required_budget_with_buffer#1) with required_budget_with_buffer#0 in current definition for 5 blocks +debug: Added fee_source#1 to Phi node: let fee_source#4: uint64 = φ(fee_source#1 <- block@2) in block@2 +debug: Replacing trivial Phi node: let fee_source#4: uint64 = φ(fee_source#1 <- block@2) (fee_source#4) with fee_source#1 +debug: Deleting Phi assignment: let fee_source#4: uint64 = φ(fee_source#1 <- block@2) +debug: Replacing trivial Phi node: let fee_source#2: uint64 = φ(fee_source#1 <- block@2, fee_source#1 <- block@3, fee_source#1 <- block@4) (fee_source#2) with fee_source#1 +debug: Deleting Phi assignment: let fee_source#2: uint64 = φ(fee_source#1 <- block@2, fee_source#1 <- block@3, fee_source#1 <- block@4) +debug: Replacing trivial Phi node: let fee_source#1: uint64 = φ(fee_source#0 <- block@0, fee_source#1 <- block@5) (fee_source#1) with fee_source#0 +debug: Deleting Phi assignment: let fee_source#1: uint64 = φ(fee_source#0 <- block@0, fee_source#1 <- block@5) +debug: Replaced trivial Phi node: let fee_source#4: uint64 = φ(fee_source#1 <- block@2) (fee_source#4) with fee_source#1 in current definition for 1 blocks +debug: Replaced trivial Phi node: let fee_source#2: uint64 = φ(fee_source#1 <- block@2, fee_source#1 <- block@3, fee_source#1 <- block@4) (fee_source#2) with fee_source#1 in current definition for 1 blocks +debug: Replaced trivial Phi node: let fee_source#1: uint64 = φ(fee_source#0 <- block@0, fee_source#1 <- block@5) (fee_source#1) with fee_source#0 in current definition for 5 blocks +debug: Building IR for function _puya_lib.bytes_.is_substring +debug: Sealing block@0 +debug: Terminated block@0 +debug: Looking for 'start' in an unsealed block creating an incomplete Phi: block@1 +debug: Created Phi assignment: let start#1: uint64 = undefined while trying to resolve 'start' in block@1 +debug: Looking for 'item' in an unsealed block creating an incomplete Phi: block@1 +debug: Created Phi assignment: let item#1: bytes = undefined while trying to resolve 'item' in block@1 +debug: Looking for 'sequence' in an unsealed block creating an incomplete Phi: block@1 +debug: Created Phi assignment: let sequence#1: bytes = undefined while trying to resolve 'sequence' in block@1 +debug: Terminated block@1 +debug: Sealing block@2 +debug: Terminated block@2 +debug: Sealing block@3 +debug: Terminated block@3 +debug: Sealing block@4 +debug: Terminated block@4 +debug: Sealing block@1 +debug: Added start#0 to Phi node: let start#1: uint64 = φ(start#0 <- block@0) in block@0 +debug: Added start#2 to Phi node: let start#1: uint64 = φ(start#0 <- block@0, start#2 <- block@4) in block@4 +debug: Added item#0 to Phi node: let item#1: bytes = φ(item#0 <- block@0) in block@0 +debug: Added item#1 to Phi node: let item#1: bytes = φ(item#0 <- block@0, item#1 <- block@4) in block@4 +debug: Replacing trivial Phi node: let item#1: bytes = φ(item#0 <- block@0, item#1 <- block@4) (item#1) with item#0 +debug: Deleting Phi assignment: let item#1: bytes = φ(item#0 <- block@0, item#1 <- block@4) +debug: Replaced trivial Phi node: let item#1: bytes = φ(item#0 <- block@0, item#1 <- block@4) (item#1) with item#0 in current definition for 3 blocks +debug: Added sequence#0 to Phi node: let sequence#1: bytes = φ(sequence#0 <- block@0) in block@0 +debug: Added sequence#1 to Phi node: let sequence#1: bytes = φ(sequence#0 <- block@0, sequence#1 <- block@4) in block@4 +debug: Replacing trivial Phi node: let sequence#1: bytes = φ(sequence#0 <- block@0, sequence#1 <- block@4) (sequence#1) with sequence#0 +debug: Deleting Phi assignment: let sequence#1: bytes = φ(sequence#0 <- block@0, sequence#1 <- block@4) +debug: Replaced trivial Phi node: let sequence#1: bytes = φ(sequence#0 <- block@0, sequence#1 <- block@4) (sequence#1) with sequence#0 in current definition for 3 blocks +debug: Sealing block@5 +debug: Terminated block@5 +debug: Building IR for function _puya_lib.arc4.dynamic_array_pop_bit +debug: Sealing block@0 +debug: Terminated block@0 +debug: Building IR for function _puya_lib.arc4.dynamic_array_pop_fixed_size +debug: Sealing block@0 +debug: Terminated block@0 +debug: Building IR for function _puya_lib.arc4.dynamic_array_pop_byte_length_head +debug: Sealing block@0 +debug: Terminated block@0 +debug: Building IR for function _puya_lib.arc4.dynamic_array_pop_dynamic_element +debug: Sealing block@0 +debug: Terminated block@0 +debug: Looking for 'value_internal%0' in an unsealed block creating an incomplete Phi: block@1 +debug: Created Phi assignment: let value_internal%0#1: uint64 = undefined while trying to resolve 'value_internal%0' in block@1 +debug: Terminated block@1 +debug: Sealing block@2 +debug: Looking for 'head_and_tail' in an unsealed block creating an incomplete Phi: block@1 +debug: Created Phi assignment: let head_and_tail#1: bytes = undefined while trying to resolve 'head_and_tail' in block@1 +debug: Looking for 'new_head' in an unsealed block creating an incomplete Phi: block@1 +debug: Created Phi assignment: let new_head#1: bytes = undefined while trying to resolve 'new_head' in block@1 +debug: Terminated block@2 +debug: Sealing block@3 +debug: Terminated block@3 +debug: Sealing block@1 +debug: Added value_internal%0#0 to Phi node: let value_internal%0#1: uint64 = φ(value_internal%0#0 <- block@0) in block@0 +debug: Added value_internal%0#2 to Phi node: let value_internal%0#1: uint64 = φ(value_internal%0#0 <- block@0, value_internal%0#2 <- block@3) in block@3 +debug: Added head_and_tail#0 to Phi node: let head_and_tail#1: bytes = φ(head_and_tail#0 <- block@0) in block@0 +debug: Added head_and_tail#1 to Phi node: let head_and_tail#1: bytes = φ(head_and_tail#0 <- block@0, head_and_tail#1 <- block@3) in block@3 +debug: Replacing trivial Phi node: let head_and_tail#1: bytes = φ(head_and_tail#0 <- block@0, head_and_tail#1 <- block@3) (head_and_tail#1) with head_and_tail#0 +debug: Deleting Phi assignment: let head_and_tail#1: bytes = φ(head_and_tail#0 <- block@0, head_and_tail#1 <- block@3) +debug: Replaced trivial Phi node: let head_and_tail#1: bytes = φ(head_and_tail#0 <- block@0, head_and_tail#1 <- block@3) (head_and_tail#1) with head_and_tail#0 in current definition for 3 blocks +debug: Added new_head#0 to Phi node: let new_head#1: bytes = φ(new_head#0 <- block@0) in block@0 +debug: Added new_head#2 to Phi node: let new_head#1: bytes = φ(new_head#0 <- block@0, new_head#2 <- block@3) in block@3 +debug: Sealing block@4 +debug: Created Phi assignment: let length_minus_1#1: uint64 = undefined while trying to resolve 'length_minus_1' in block@1 +debug: Added length_minus_1#0 to Phi node: let length_minus_1#1: uint64 = φ(length_minus_1#0 <- block@0) in block@0 +debug: Added length_minus_1#1 to Phi node: let length_minus_1#1: uint64 = φ(length_minus_1#0 <- block@0, length_minus_1#1 <- block@3) in block@3 +debug: Replacing trivial Phi node: let length_minus_1#1: uint64 = φ(length_minus_1#0 <- block@0, length_minus_1#1 <- block@3) (length_minus_1#1) with length_minus_1#0 +debug: Deleting Phi assignment: let length_minus_1#1: uint64 = φ(length_minus_1#0 <- block@0, length_minus_1#1 <- block@3) +debug: Replaced trivial Phi node: let length_minus_1#1: uint64 = φ(length_minus_1#0 <- block@0, length_minus_1#1 <- block@3) (length_minus_1#1) with length_minus_1#0 in current definition for 3 blocks +debug: Created Phi assignment: let popped_header_offset#1: uint64 = undefined while trying to resolve 'popped_header_offset' in block@1 +debug: Added popped_header_offset#0 to Phi node: let popped_header_offset#1: uint64 = φ(popped_header_offset#0 <- block@0) in block@0 +debug: Added popped_header_offset#1 to Phi node: let popped_header_offset#1: uint64 = φ(popped_header_offset#0 <- block@0, popped_header_offset#1 <- block@3) in block@3 +debug: Replacing trivial Phi node: let popped_header_offset#1: uint64 = φ(popped_header_offset#0 <- block@0, popped_header_offset#1 <- block@3) (popped_header_offset#1) with popped_header_offset#0 +debug: Deleting Phi assignment: let popped_header_offset#1: uint64 = φ(popped_header_offset#0 <- block@0, popped_header_offset#1 <- block@3) +debug: Replaced trivial Phi node: let popped_header_offset#1: uint64 = φ(popped_header_offset#0 <- block@0, popped_header_offset#1 <- block@3) (popped_header_offset#1) with popped_header_offset#0 in current definition for 3 blocks +debug: Created Phi assignment: let popped_offset#1: uint64 = undefined while trying to resolve 'popped_offset' in block@1 +debug: Added popped_offset#0 to Phi node: let popped_offset#1: uint64 = φ(popped_offset#0 <- block@0) in block@0 +debug: Added popped_offset#1 to Phi node: let popped_offset#1: uint64 = φ(popped_offset#0 <- block@0, popped_offset#1 <- block@3) in block@3 +debug: Replacing trivial Phi node: let popped_offset#1: uint64 = φ(popped_offset#0 <- block@0, popped_offset#1 <- block@3) (popped_offset#1) with popped_offset#0 +debug: Deleting Phi assignment: let popped_offset#1: uint64 = φ(popped_offset#0 <- block@0, popped_offset#1 <- block@3) +debug: Replaced trivial Phi node: let popped_offset#1: uint64 = φ(popped_offset#0 <- block@0, popped_offset#1 <- block@3) (popped_offset#1) with popped_offset#0 in current definition for 3 blocks +debug: Created Phi assignment: let popped#1: bytes = undefined while trying to resolve 'popped' in block@1 +debug: Added popped#0 to Phi node: let popped#1: bytes = φ(popped#0 <- block@0) in block@0 +debug: Added popped#1 to Phi node: let popped#1: bytes = φ(popped#0 <- block@0, popped#1 <- block@3) in block@3 +debug: Replacing trivial Phi node: let popped#1: bytes = φ(popped#0 <- block@0, popped#1 <- block@3) (popped#1) with popped#0 +debug: Deleting Phi assignment: let popped#1: bytes = φ(popped#0 <- block@0, popped#1 <- block@3) +debug: Replaced trivial Phi node: let popped#1: bytes = φ(popped#0 <- block@0, popped#1 <- block@3) (popped#1) with popped#0 in current definition for 3 blocks +debug: Terminated block@4 +debug: Building IR for function _puya_lib.arc4.dynamic_array_concat_bits +debug: Sealing block@0 +debug: Terminated block@0 +debug: Sealing block@1 +debug: Terminated block@1 +debug: Sealing block@2 +debug: Created Phi assignment: let array_length#1: uint64 = undefined while trying to resolve 'array_length' in block@2 +debug: Added array_length#0 to Phi node: let array_length#1: uint64 = φ(array_length#0 <- block@0) in block@0 +debug: Added array_length#0 to Phi node: let array_length#1: uint64 = φ(array_length#0 <- block@0, array_length#0 <- block@1) in block@1 +debug: Replacing trivial Phi node: let array_length#1: uint64 = φ(array_length#0 <- block@0, array_length#0 <- block@1) (array_length#1) with array_length#0 +debug: Deleting Phi assignment: let array_length#1: uint64 = φ(array_length#0 <- block@0, array_length#0 <- block@1) +debug: Replaced trivial Phi node: let array_length#1: uint64 = φ(array_length#0 <- block@0, array_length#0 <- block@1) (array_length#1) with array_length#0 in current definition for 1 blocks +debug: Created Phi assignment: let new_items_count#1: uint64 = undefined while trying to resolve 'new_items_count' in block@2 +debug: Added new_items_count#0 to Phi node: let new_items_count#1: uint64 = φ(new_items_count#0 <- block@0) in block@0 +debug: Added new_items_count#0 to Phi node: let new_items_count#1: uint64 = φ(new_items_count#0 <- block@0, new_items_count#0 <- block@1) in block@1 +debug: Replacing trivial Phi node: let new_items_count#1: uint64 = φ(new_items_count#0 <- block@0, new_items_count#0 <- block@1) (new_items_count#1) with new_items_count#0 +debug: Deleting Phi assignment: let new_items_count#1: uint64 = φ(new_items_count#0 <- block@0, new_items_count#0 <- block@1) +debug: Replaced trivial Phi node: let new_items_count#1: uint64 = φ(new_items_count#0 <- block@0, new_items_count#0 <- block@1) (new_items_count#1) with new_items_count#0 in current definition for 1 blocks +debug: Terminated block@2 +debug: Looking for 'write_offset' in an unsealed block creating an incomplete Phi: block@3 +debug: Created Phi assignment: let write_offset#1: uint64 = undefined while trying to resolve 'write_offset' in block@3 +debug: Looking for 'write_end' in an unsealed block creating an incomplete Phi: block@3 +debug: Created Phi assignment: let write_end#1: uint64 = undefined while trying to resolve 'write_end' in block@3 +debug: Terminated block@3 +debug: Sealing block@4 +debug: Looking for 'result' in an unsealed block creating an incomplete Phi: block@3 +debug: Created Phi assignment: let result#2: bytes = undefined while trying to resolve 'result' in block@3 +debug: Looking for 'new_items_bytes' in an unsealed block creating an incomplete Phi: block@3 +debug: Created Phi assignment: let new_items_bytes#1: bytes = undefined while trying to resolve 'new_items_bytes' in block@3 +debug: Looking for 'read_offset' in an unsealed block creating an incomplete Phi: block@3 +debug: Created Phi assignment: let read_offset#1: uint64 = undefined while trying to resolve 'read_offset' in block@3 +debug: Looking for 'read_step' in an unsealed block creating an incomplete Phi: block@3 +debug: Created Phi assignment: let read_step#1: uint64 = undefined while trying to resolve 'read_step' in block@3 +debug: Terminated block@4 +debug: Sealing block@3 +debug: Added write_offset#0 to Phi node: let write_offset#1: uint64 = φ(write_offset#0 <- block@2) in block@2 +debug: Added write_offset#2 to Phi node: let write_offset#1: uint64 = φ(write_offset#0 <- block@2, write_offset#2 <- block@4) in block@4 +debug: Added write_end#0 to Phi node: let write_end#1: uint64 = φ(write_end#0 <- block@2) in block@2 +debug: Added write_end#1 to Phi node: let write_end#1: uint64 = φ(write_end#0 <- block@2, write_end#1 <- block@4) in block@4 +debug: Replacing trivial Phi node: let write_end#1: uint64 = φ(write_end#0 <- block@2, write_end#1 <- block@4) (write_end#1) with write_end#0 +debug: Deleting Phi assignment: let write_end#1: uint64 = φ(write_end#0 <- block@2, write_end#1 <- block@4) +debug: Replaced trivial Phi node: let write_end#1: uint64 = φ(write_end#0 <- block@2, write_end#1 <- block@4) (write_end#1) with write_end#0 in current definition for 2 blocks +debug: Created Phi assignment: let result#4: bytes = undefined while trying to resolve 'result' in block@2 +debug: Added result#0 to Phi node: let result#4: bytes = φ(result#0 <- block@0) in block@0 +debug: Added result#1 to Phi node: let result#4: bytes = φ(result#0 <- block@0, result#1 <- block@1) in block@1 +debug: Added result#4 to Phi node: let result#2: bytes = φ(result#4 <- block@2) in block@2 +debug: Added result#3 to Phi node: let result#2: bytes = φ(result#4 <- block@2, result#3 <- block@4) in block@4 +debug: Created Phi assignment: let new_items_bytes#2: bytes = undefined while trying to resolve 'new_items_bytes' in block@2 +debug: Added new_items_bytes#0 to Phi node: let new_items_bytes#2: bytes = φ(new_items_bytes#0 <- block@0) in block@0 +debug: Added new_items_bytes#0 to Phi node: let new_items_bytes#2: bytes = φ(new_items_bytes#0 <- block@0, new_items_bytes#0 <- block@1) in block@1 +debug: Replacing trivial Phi node: let new_items_bytes#2: bytes = φ(new_items_bytes#0 <- block@0, new_items_bytes#0 <- block@1) (new_items_bytes#2) with new_items_bytes#0 +debug: Deleting Phi assignment: let new_items_bytes#2: bytes = φ(new_items_bytes#0 <- block@0, new_items_bytes#0 <- block@1) +debug: Replaced trivial Phi node: let new_items_bytes#2: bytes = φ(new_items_bytes#0 <- block@0, new_items_bytes#0 <- block@1) (new_items_bytes#2) with new_items_bytes#0 in current definition for 1 blocks +debug: Added new_items_bytes#0 to Phi node: let new_items_bytes#1: bytes = φ(new_items_bytes#0 <- block@2) in block@2 +debug: Added new_items_bytes#1 to Phi node: let new_items_bytes#1: bytes = φ(new_items_bytes#0 <- block@2, new_items_bytes#1 <- block@4) in block@4 +debug: Replacing trivial Phi node: let new_items_bytes#1: bytes = φ(new_items_bytes#0 <- block@2, new_items_bytes#1 <- block@4) (new_items_bytes#1) with new_items_bytes#0 +debug: Deleting Phi assignment: let new_items_bytes#1: bytes = φ(new_items_bytes#0 <- block@2, new_items_bytes#1 <- block@4) +debug: Replaced trivial Phi node: let new_items_bytes#1: bytes = φ(new_items_bytes#0 <- block@2, new_items_bytes#1 <- block@4) (new_items_bytes#1) with new_items_bytes#0 in current definition for 2 blocks +debug: Added read_offset#0 to Phi node: let read_offset#1: uint64 = φ(read_offset#0 <- block@2) in block@2 +debug: Added read_offset#2 to Phi node: let read_offset#1: uint64 = φ(read_offset#0 <- block@2, read_offset#2 <- block@4) in block@4 +debug: Created Phi assignment: let read_step#2: uint64 = undefined while trying to resolve 'read_step' in block@2 +debug: Added read_step#0 to Phi node: let read_step#2: uint64 = φ(read_step#0 <- block@0) in block@0 +debug: Added read_step#0 to Phi node: let read_step#2: uint64 = φ(read_step#0 <- block@0, read_step#0 <- block@1) in block@1 +debug: Replacing trivial Phi node: let read_step#2: uint64 = φ(read_step#0 <- block@0, read_step#0 <- block@1) (read_step#2) with read_step#0 +debug: Deleting Phi assignment: let read_step#2: uint64 = φ(read_step#0 <- block@0, read_step#0 <- block@1) +debug: Replaced trivial Phi node: let read_step#2: uint64 = φ(read_step#0 <- block@0, read_step#0 <- block@1) (read_step#2) with read_step#0 in current definition for 1 blocks +debug: Added read_step#0 to Phi node: let read_step#1: uint64 = φ(read_step#0 <- block@2) in block@2 +debug: Added read_step#1 to Phi node: let read_step#1: uint64 = φ(read_step#0 <- block@2, read_step#1 <- block@4) in block@4 +debug: Replacing trivial Phi node: let read_step#1: uint64 = φ(read_step#0 <- block@2, read_step#1 <- block@4) (read_step#1) with read_step#0 +debug: Deleting Phi assignment: let read_step#1: uint64 = φ(read_step#0 <- block@2, read_step#1 <- block@4) +debug: Replaced trivial Phi node: let read_step#1: uint64 = φ(read_step#0 <- block@2, read_step#1 <- block@4) (read_step#1) with read_step#0 in current definition for 2 blocks +debug: Sealing block@5 +debug: Terminated block@5 +debug: Building IR for function _puya_lib.arc4.dynamic_array_concat_byte_length_head +debug: Sealing block@0 +debug: Terminated block@0 +debug: Building IR for function _puya_lib.arc4.dynamic_array_concat_dynamic_element +debug: Sealing block@0 +debug: Terminated block@0 +debug: Looking for 'value_internal%0' in an unsealed block creating an incomplete Phi: block@1 +debug: Created Phi assignment: let value_internal%0#1: uint64 = undefined while trying to resolve 'value_internal%0' in block@1 +debug: Terminated block@1 +debug: Sealing block@2 +debug: Looking for 'array_head_and_tail' in an unsealed block creating an incomplete Phi: block@1 +debug: Created Phi assignment: let array_head_and_tail#1: bytes = undefined while trying to resolve 'array_head_and_tail' in block@1 +debug: Looking for 'new_head' in an unsealed block creating an incomplete Phi: block@1 +debug: Created Phi assignment: let new_head#1: bytes = undefined while trying to resolve 'new_head' in block@1 +debug: Looking for 'item_offset_adjustment' in an unsealed block creating an incomplete Phi: block@1 +debug: Created Phi assignment: let item_offset_adjustment#1: uint64 = undefined while trying to resolve 'item_offset_adjustment' in block@1 +debug: Terminated block@2 +debug: Sealing block@3 +debug: Terminated block@3 +debug: Sealing block@1 +debug: Added value_internal%0#0 to Phi node: let value_internal%0#1: uint64 = φ(value_internal%0#0 <- block@0) in block@0 +debug: Added value_internal%0#2 to Phi node: let value_internal%0#1: uint64 = φ(value_internal%0#0 <- block@0, value_internal%0#2 <- block@3) in block@3 +debug: Added array_head_and_tail#0 to Phi node: let array_head_and_tail#1: bytes = φ(array_head_and_tail#0 <- block@0) in block@0 +debug: Added array_head_and_tail#1 to Phi node: let array_head_and_tail#1: bytes = φ(array_head_and_tail#0 <- block@0, array_head_and_tail#1 <- block@3) in block@3 +debug: Replacing trivial Phi node: let array_head_and_tail#1: bytes = φ(array_head_and_tail#0 <- block@0, array_head_and_tail#1 <- block@3) (array_head_and_tail#1) with array_head_and_tail#0 +debug: Deleting Phi assignment: let array_head_and_tail#1: bytes = φ(array_head_and_tail#0 <- block@0, array_head_and_tail#1 <- block@3) +debug: Replaced trivial Phi node: let array_head_and_tail#1: bytes = φ(array_head_and_tail#0 <- block@0, array_head_and_tail#1 <- block@3) (array_head_and_tail#1) with array_head_and_tail#0 in current definition for 3 blocks +debug: Added new_head#0 to Phi node: let new_head#1: bytes = φ(new_head#0 <- block@0) in block@0 +debug: Added new_head#2 to Phi node: let new_head#1: bytes = φ(new_head#0 <- block@0, new_head#2 <- block@3) in block@3 +debug: Added item_offset_adjustment#0 to Phi node: let item_offset_adjustment#1: uint64 = φ(item_offset_adjustment#0 <- block@0) in block@0 +debug: Added item_offset_adjustment#1 to Phi node: let item_offset_adjustment#1: uint64 = φ(item_offset_adjustment#0 <- block@0, item_offset_adjustment#1 <- block@3) in block@3 +debug: Replacing trivial Phi node: let item_offset_adjustment#1: uint64 = φ(item_offset_adjustment#0 <- block@0, item_offset_adjustment#1 <- block@3) (item_offset_adjustment#1) with item_offset_adjustment#0 +debug: Deleting Phi assignment: let item_offset_adjustment#1: uint64 = φ(item_offset_adjustment#0 <- block@0, item_offset_adjustment#1 <- block@3) +debug: Replaced trivial Phi node: let item_offset_adjustment#1: uint64 = φ(item_offset_adjustment#0 <- block@0, item_offset_adjustment#1 <- block@3) (item_offset_adjustment#1) with item_offset_adjustment#0 in current definition for 3 blocks +debug: Sealing block@4 +debug: Created Phi assignment: let new_items_count#1: uint64 = undefined while trying to resolve 'new_items_count' in block@1 +debug: Added new_items_count#0 to Phi node: let new_items_count#1: uint64 = φ(new_items_count#0 <- block@0) in block@0 +debug: Added new_items_count#1 to Phi node: let new_items_count#1: uint64 = φ(new_items_count#0 <- block@0, new_items_count#1 <- block@3) in block@3 +debug: Replacing trivial Phi node: let new_items_count#1: uint64 = φ(new_items_count#0 <- block@0, new_items_count#1 <- block@3) (new_items_count#1) with new_items_count#0 +debug: Deleting Phi assignment: let new_items_count#1: uint64 = φ(new_items_count#0 <- block@0, new_items_count#1 <- block@3) +debug: Replaced trivial Phi node: let new_items_count#1: uint64 = φ(new_items_count#0 <- block@0, new_items_count#1 <- block@3) (new_items_count#1) with new_items_count#0 in current definition for 3 blocks +debug: Terminated block@4 +debug: Looking for 'value_internal%1' in an unsealed block creating an incomplete Phi: block@5 +debug: Created Phi assignment: let value_internal%1#1: uint64 = undefined while trying to resolve 'value_internal%1' in block@5 +debug: Terminated block@5 +debug: Sealing block@6 +debug: Looking for 'new_head_and_tail' in an unsealed block creating an incomplete Phi: block@5 +debug: Created Phi assignment: let new_head_and_tail#1: bytes = undefined while trying to resolve 'new_head_and_tail' in block@5 +debug: Looking for 'new_head' in an unsealed block creating an incomplete Phi: block@5 +debug: Created Phi assignment: let new_head#3: bytes = undefined while trying to resolve 'new_head' in block@5 +debug: Looking for 'head_and_tail_length' in an unsealed block creating an incomplete Phi: block@5 +debug: Created Phi assignment: let head_and_tail_length#1: uint64 = undefined while trying to resolve 'head_and_tail_length' in block@5 +debug: Terminated block@6 +debug: Sealing block@7 +debug: Terminated block@7 +debug: Sealing block@5 +debug: Added value_internal%1#0 to Phi node: let value_internal%1#1: uint64 = φ(value_internal%1#0 <- block@4) in block@4 +debug: Added value_internal%1#2 to Phi node: let value_internal%1#1: uint64 = φ(value_internal%1#0 <- block@4, value_internal%1#2 <- block@7) in block@7 +debug: Created Phi assignment: let new_head_and_tail#2: bytes = undefined while trying to resolve 'new_head_and_tail' in block@1 +debug: Added new_head_and_tail#0 to Phi node: let new_head_and_tail#2: bytes = φ(new_head_and_tail#0 <- block@0) in block@0 +debug: Added new_head_and_tail#2 to Phi node: let new_head_and_tail#2: bytes = φ(new_head_and_tail#0 <- block@0, new_head_and_tail#2 <- block@3) in block@3 +debug: Replacing trivial Phi node: let new_head_and_tail#2: bytes = φ(new_head_and_tail#0 <- block@0, new_head_and_tail#2 <- block@3) (new_head_and_tail#2) with new_head_and_tail#0 +debug: Deleting Phi assignment: let new_head_and_tail#2: bytes = φ(new_head_and_tail#0 <- block@0, new_head_and_tail#2 <- block@3) +debug: Replaced trivial Phi node: let new_head_and_tail#2: bytes = φ(new_head_and_tail#0 <- block@0, new_head_and_tail#2 <- block@3) (new_head_and_tail#2) with new_head_and_tail#0 in current definition for 3 blocks +debug: Added new_head_and_tail#0 to Phi node: let new_head_and_tail#1: bytes = φ(new_head_and_tail#0 <- block@4) in block@4 +debug: Added new_head_and_tail#1 to Phi node: let new_head_and_tail#1: bytes = φ(new_head_and_tail#0 <- block@4, new_head_and_tail#1 <- block@7) in block@7 +debug: Replacing trivial Phi node: let new_head_and_tail#1: bytes = φ(new_head_and_tail#0 <- block@4, new_head_and_tail#1 <- block@7) (new_head_and_tail#1) with new_head_and_tail#0 +debug: Deleting Phi assignment: let new_head_and_tail#1: bytes = φ(new_head_and_tail#0 <- block@4, new_head_and_tail#1 <- block@7) +debug: Replaced trivial Phi node: let new_head_and_tail#1: bytes = φ(new_head_and_tail#0 <- block@4, new_head_and_tail#1 <- block@7) (new_head_and_tail#1) with new_head_and_tail#0 in current definition for 3 blocks +debug: Added new_head#1 to Phi node: let new_head#3: bytes = φ(new_head#1 <- block@4) in block@4 +debug: Added new_head#4 to Phi node: let new_head#3: bytes = φ(new_head#1 <- block@4, new_head#4 <- block@7) in block@7 +debug: Added head_and_tail_length#0 to Phi node: let head_and_tail_length#1: uint64 = φ(head_and_tail_length#0 <- block@4) in block@4 +debug: Added head_and_tail_length#1 to Phi node: let head_and_tail_length#1: uint64 = φ(head_and_tail_length#0 <- block@4, head_and_tail_length#1 <- block@7) in block@7 +debug: Replacing trivial Phi node: let head_and_tail_length#1: uint64 = φ(head_and_tail_length#0 <- block@4, head_and_tail_length#1 <- block@7) (head_and_tail_length#1) with head_and_tail_length#0 +debug: Deleting Phi assignment: let head_and_tail_length#1: uint64 = φ(head_and_tail_length#0 <- block@4, head_and_tail_length#1 <- block@7) +debug: Replaced trivial Phi node: let head_and_tail_length#1: uint64 = φ(head_and_tail_length#0 <- block@4, head_and_tail_length#1 <- block@7) (head_and_tail_length#1) with head_and_tail_length#0 in current definition for 3 blocks +debug: Sealing block@8 +debug: Created Phi assignment: let array_items_count#1: uint64 = undefined while trying to resolve 'array_items_count' in block@5 +debug: Created Phi assignment: let array_items_count#2: uint64 = undefined while trying to resolve 'array_items_count' in block@1 +debug: Added array_items_count#0 to Phi node: let array_items_count#2: uint64 = φ(array_items_count#0 <- block@0) in block@0 +debug: Added array_items_count#2 to Phi node: let array_items_count#2: uint64 = φ(array_items_count#0 <- block@0, array_items_count#2 <- block@3) in block@3 +debug: Replacing trivial Phi node: let array_items_count#2: uint64 = φ(array_items_count#0 <- block@0, array_items_count#2 <- block@3) (array_items_count#2) with array_items_count#0 +debug: Deleting Phi assignment: let array_items_count#2: uint64 = φ(array_items_count#0 <- block@0, array_items_count#2 <- block@3) +debug: Replaced trivial Phi node: let array_items_count#2: uint64 = φ(array_items_count#0 <- block@0, array_items_count#2 <- block@3) (array_items_count#2) with array_items_count#0 in current definition for 3 blocks +debug: Added array_items_count#0 to Phi node: let array_items_count#1: uint64 = φ(array_items_count#0 <- block@4) in block@4 +debug: Added array_items_count#1 to Phi node: let array_items_count#1: uint64 = φ(array_items_count#0 <- block@4, array_items_count#1 <- block@7) in block@7 +debug: Replacing trivial Phi node: let array_items_count#1: uint64 = φ(array_items_count#0 <- block@4, array_items_count#1 <- block@7) (array_items_count#1) with array_items_count#0 +debug: Deleting Phi assignment: let array_items_count#1: uint64 = φ(array_items_count#0 <- block@4, array_items_count#1 <- block@7) +debug: Replaced trivial Phi node: let array_items_count#1: uint64 = φ(array_items_count#0 <- block@4, array_items_count#1 <- block@7) (array_items_count#1) with array_items_count#0 in current definition for 3 blocks +debug: Created Phi assignment: let new_items_count#2: uint64 = undefined while trying to resolve 'new_items_count' in block@5 +debug: Added new_items_count#0 to Phi node: let new_items_count#2: uint64 = φ(new_items_count#0 <- block@4) in block@4 +debug: Added new_items_count#2 to Phi node: let new_items_count#2: uint64 = φ(new_items_count#0 <- block@4, new_items_count#2 <- block@7) in block@7 +debug: Replacing trivial Phi node: let new_items_count#2: uint64 = φ(new_items_count#0 <- block@4, new_items_count#2 <- block@7) (new_items_count#2) with new_items_count#0 +debug: Deleting Phi assignment: let new_items_count#2: uint64 = φ(new_items_count#0 <- block@4, new_items_count#2 <- block@7) +debug: Replaced trivial Phi node: let new_items_count#2: uint64 = φ(new_items_count#0 <- block@4, new_items_count#2 <- block@7) (new_items_count#2) with new_items_count#0 in current definition for 3 blocks +debug: Created Phi assignment: let array_head_and_tail#2: bytes = undefined while trying to resolve 'array_head_and_tail' in block@5 +debug: Added array_head_and_tail#0 to Phi node: let array_head_and_tail#2: bytes = φ(array_head_and_tail#0 <- block@4) in block@4 +debug: Added array_head_and_tail#2 to Phi node: let array_head_and_tail#2: bytes = φ(array_head_and_tail#0 <- block@4, array_head_and_tail#2 <- block@7) in block@7 +debug: Replacing trivial Phi node: let array_head_and_tail#2: bytes = φ(array_head_and_tail#0 <- block@4, array_head_and_tail#2 <- block@7) (array_head_and_tail#2) with array_head_and_tail#0 +debug: Deleting Phi assignment: let array_head_and_tail#2: bytes = φ(array_head_and_tail#0 <- block@4, array_head_and_tail#2 <- block@7) +debug: Replaced trivial Phi node: let array_head_and_tail#2: bytes = φ(array_head_and_tail#0 <- block@4, array_head_and_tail#2 <- block@7) (array_head_and_tail#2) with array_head_and_tail#0 in current definition for 3 blocks +debug: Terminated block@8 +debug: Building IR for function _puya_lib.arc4.dynamic_array_replace_byte_length_head +debug: Sealing block@0 +debug: Terminated block@0 +debug: Building IR for function _puya_lib.arc4.dynamic_array_replace_dynamic_element +debug: Sealing block@0 +debug: Terminated block@0 +debug: Building IR for function _puya_lib.arc4.static_array_replace_dynamic_element +debug: Sealing block@0 +debug: Terminated block@0 +debug: Looking for 'value_internal%0' in an unsealed block creating an incomplete Phi: block@1 +debug: Created Phi assignment: let value_internal%0#1: uint64 = undefined while trying to resolve 'value_internal%0' in block@1 +debug: Terminated block@1 +debug: Sealing block@2 +debug: Looking for 'new_head_and_tail' in an unsealed block creating an incomplete Phi: block@1 +debug: Created Phi assignment: let new_head_and_tail#1: bytes = undefined while trying to resolve 'new_head_and_tail' in block@1 +debug: Looking for 'new_item_length' in an unsealed block creating an incomplete Phi: block@1 +debug: Created Phi assignment: let new_item_length#1: uint64 = undefined while trying to resolve 'new_item_length' in block@1 +debug: Looking for 'original_item_length' in an unsealed block creating an incomplete Phi: block@1 +debug: Created Phi assignment: let original_item_length#1: uint64 = undefined while trying to resolve 'original_item_length' in block@1 +debug: Terminated block@2 +debug: Sealing block@3 +debug: Terminated block@3 +debug: Sealing block@1 +debug: Added value_internal%0#0 to Phi node: let value_internal%0#1: uint64 = φ(value_internal%0#0 <- block@0) in block@0 +debug: Added value_internal%0#2 to Phi node: let value_internal%0#1: uint64 = φ(value_internal%0#0 <- block@0, value_internal%0#2 <- block@3) in block@3 +debug: Added new_head_and_tail#0 to Phi node: let new_head_and_tail#1: bytes = φ(new_head_and_tail#0 <- block@0) in block@0 +debug: Added new_head_and_tail#2 to Phi node: let new_head_and_tail#1: bytes = φ(new_head_and_tail#0 <- block@0, new_head_and_tail#2 <- block@3) in block@3 +debug: Added new_item_length#0 to Phi node: let new_item_length#1: uint64 = φ(new_item_length#0 <- block@0) in block@0 +debug: Added new_item_length#1 to Phi node: let new_item_length#1: uint64 = φ(new_item_length#0 <- block@0, new_item_length#1 <- block@3) in block@3 +debug: Replacing trivial Phi node: let new_item_length#1: uint64 = φ(new_item_length#0 <- block@0, new_item_length#1 <- block@3) (new_item_length#1) with new_item_length#0 +debug: Deleting Phi assignment: let new_item_length#1: uint64 = φ(new_item_length#0 <- block@0, new_item_length#1 <- block@3) +debug: Replaced trivial Phi node: let new_item_length#1: uint64 = φ(new_item_length#0 <- block@0, new_item_length#1 <- block@3) (new_item_length#1) with new_item_length#0 in current definition for 3 blocks +debug: Added original_item_length#0 to Phi node: let original_item_length#1: uint64 = φ(original_item_length#0 <- block@0) in block@0 +debug: Added original_item_length#1 to Phi node: let original_item_length#1: uint64 = φ(original_item_length#0 <- block@0, original_item_length#1 <- block@3) in block@3 +debug: Replacing trivial Phi node: let original_item_length#1: uint64 = φ(original_item_length#0 <- block@0, original_item_length#1 <- block@3) (original_item_length#1) with original_item_length#0 +debug: Deleting Phi assignment: let original_item_length#1: uint64 = φ(original_item_length#0 <- block@0, original_item_length#1 <- block@3) +debug: Replaced trivial Phi node: let original_item_length#1: uint64 = φ(original_item_length#0 <- block@0, original_item_length#1 <- block@3) (original_item_length#1) with original_item_length#0 in current definition for 3 blocks +debug: Sealing block@4 +debug: Terminated block@4 +debug: Building IR for function _puya_lib.arc4.static_array_replace_byte_length_head +debug: Sealing block@0 +debug: Terminated block@0 +debug: Building IR for function _puya_lib.arc4.recalculate_head_for_elements_with_byte_length_head +debug: Sealing block@0 +debug: Terminated block@0 +debug: Looking for 'value_internal%0' in an unsealed block creating an incomplete Phi: block@1 +debug: Created Phi assignment: let value_internal%0#1: uint64 = undefined while trying to resolve 'value_internal%0' in block@1 +debug: Terminated block@1 +debug: Sealing block@2 +debug: Looking for 'tail_offset' in an unsealed block creating an incomplete Phi: block@1 +debug: Created Phi assignment: let tail_offset#1: uint64 = undefined while trying to resolve 'tail_offset' in block@1 +debug: Looking for 'array_head_and_tail' in an unsealed block creating an incomplete Phi: block@1 +debug: Created Phi assignment: let array_head_and_tail#1: bytes = undefined while trying to resolve 'array_head_and_tail' in block@1 +debug: Terminated block@2 +debug: Sealing block@3 +debug: Terminated block@3 +debug: Sealing block@1 +debug: Added value_internal%0#0 to Phi node: let value_internal%0#1: uint64 = φ(value_internal%0#0 <- block@0) in block@0 +debug: Added value_internal%0#2 to Phi node: let value_internal%0#1: uint64 = φ(value_internal%0#0 <- block@0, value_internal%0#2 <- block@3) in block@3 +debug: Added tail_offset#0 to Phi node: let tail_offset#1: uint64 = φ(tail_offset#0 <- block@0) in block@0 +debug: Added tail_offset#2 to Phi node: let tail_offset#1: uint64 = φ(tail_offset#0 <- block@0, tail_offset#2 <- block@3) in block@3 +debug: Added array_head_and_tail#0 to Phi node: let array_head_and_tail#1: bytes = φ(array_head_and_tail#0 <- block@0) in block@0 +debug: Added array_head_and_tail#2 to Phi node: let array_head_and_tail#1: bytes = φ(array_head_and_tail#0 <- block@0, array_head_and_tail#2 <- block@3) in block@3 +debug: Sealing block@4 +debug: Terminated block@4 +debug: Building IR for function test_cases.structure_methods.contract.ARC4TestStruct.return_value_times +debug: Sealing block@0 +debug: Terminated block@0 +debug: Building IR for function test_cases.structure_methods.contract.ARC4TestStruct.return1 +debug: Sealing block@0 +debug: Terminated block@0 +debug: Building IR for function test_cases.structure_methods.contract.TestStruct.return_value_times +debug: Sealing block@0 +debug: Terminated block@0 +debug: Building IR for function test_cases.structure_methods.contract.TestStruct.return1 +debug: Sealing block@0 +debug: Terminated block@0 +debug: Building IR for function test_cases.structure_methods.contract.TestNamedTuple.return_value_times +debug: Sealing block@0 +debug: Terminated block@0 +debug: Building IR for function test_cases.structure_methods.contract.TestNamedTuple.return1 +debug: Sealing block@0 +debug: Terminated block@0 +debug: Building IR for function test_cases.structure_methods.contract.GroupedMethods.never_inlined_usually_inlined +debug: Sealing block@0 +debug: Terminated block@0 +debug: Building IR for function test_cases.structure_methods.contract.GroupedMethods.always_inlined_not_usually_inlined +debug: Sealing block@0 +debug: Terminated block@0 +debug: Building IR for function test_cases.structure_methods.contract.GroupedMethods.usually_inlined +debug: Sealing block@0 +debug: Terminated block@0 +debug: Building IR for function test_cases.structure_methods.contract.GroupedMethods.not_usually_inlined +debug: Sealing block@0 +debug: Terminated block@0 +debug: Building IR for function test_cases.structure_methods.contract.TestContract.__puya_arc4_router__ +debug: Sealing block@0 +debug: Terminated block@0 +debug: Sealing block@1 +debug: Terminated block@1 +debug: Sealing block@2 +debug: Terminated block@2 +debug: Sealing block@3 +debug: Terminated block@3 +debug: Sealing block@4 +debug: Terminated block@4 +debug: Sealing block@5 +debug: Terminated block@5 +debug: Building IR for function test_cases.structure_methods.contract.TestContract.test[routing] +debug: Sealing block@0 +debug: Terminated block@0 +debug: Building IR for function test_cases.structure_methods.contract.TestContract.test +debug: Sealing block@0 +debug: Terminated block@0 +debug: Building IR for function test_cases.structure_methods.contract.TestContract.__algopy_default_create +debug: Sealing block@0 +debug: Terminated block@0 +debug: Building IR for function algopy.arc4.ARC4Contract.approval_program +debug: Sealing block@0 +debug: Terminated block@0 +debug: Building IR for function algopy.arc4.ARC4Contract.clear_state_program +debug: Sealing block@0 +debug: Terminated block@0 +debug: Building IR for function algopy._contract.Contract.__init__ +debug: Sealing block@0 +debug: Terminated block@0 +debug: Building IR for function algopy.arc4.ARC4Contract.approval_program +debug: Sealing block@0 +debug: Terminated block@0 +debug: removing unused subroutine _puya_lib.util.ensure_budget +debug: removing unused subroutine _puya_lib.bytes_.is_substring +debug: removing unused subroutine _puya_lib.arc4.dynamic_array_pop_bit +debug: removing unused subroutine _puya_lib.arc4.dynamic_array_pop_fixed_size +debug: removing unused subroutine _puya_lib.arc4.dynamic_array_pop_byte_length_head +debug: removing unused subroutine _puya_lib.arc4.dynamic_array_pop_dynamic_element +debug: removing unused subroutine _puya_lib.arc4.dynamic_array_concat_bits +debug: removing unused subroutine _puya_lib.arc4.dynamic_array_concat_byte_length_head +debug: removing unused subroutine _puya_lib.arc4.dynamic_array_concat_dynamic_element +debug: removing unused subroutine _puya_lib.arc4.dynamic_array_replace_byte_length_head +debug: removing unused subroutine _puya_lib.arc4.dynamic_array_replace_dynamic_element +debug: removing unused subroutine _puya_lib.arc4.static_array_replace_dynamic_element +debug: removing unused subroutine _puya_lib.arc4.static_array_replace_byte_length_head +debug: removing unused subroutine _puya_lib.arc4.recalculate_head_for_elements_with_byte_length_head +debug: removing unused subroutine algopy.arc4.ARC4Contract.approval_program +debug: removing unused subroutine algopy.arc4.ARC4Contract.clear_state_program +debug: removing unused subroutine algopy._contract.Contract.__init__ +debug: Building IR for function algopy.arc4.ARC4Contract.clear_state_program +debug: Sealing block@0 +debug: Terminated block@0 +debug: removing unused subroutine _puya_lib.util.ensure_budget +debug: removing unused subroutine _puya_lib.bytes_.is_substring +debug: removing unused subroutine _puya_lib.arc4.dynamic_array_pop_bit +debug: removing unused subroutine _puya_lib.arc4.dynamic_array_pop_fixed_size +debug: removing unused subroutine _puya_lib.arc4.dynamic_array_pop_byte_length_head +debug: removing unused subroutine _puya_lib.arc4.dynamic_array_pop_dynamic_element +debug: removing unused subroutine _puya_lib.arc4.dynamic_array_concat_bits +debug: removing unused subroutine _puya_lib.arc4.dynamic_array_concat_byte_length_head +debug: removing unused subroutine _puya_lib.arc4.dynamic_array_concat_dynamic_element +debug: removing unused subroutine _puya_lib.arc4.dynamic_array_replace_byte_length_head +debug: removing unused subroutine _puya_lib.arc4.dynamic_array_replace_dynamic_element +debug: removing unused subroutine _puya_lib.arc4.static_array_replace_dynamic_element +debug: removing unused subroutine _puya_lib.arc4.static_array_replace_byte_length_head +debug: removing unused subroutine _puya_lib.arc4.recalculate_head_for_elements_with_byte_length_head +debug: removing unused subroutine test_cases.structure_methods.contract.ARC4TestStruct.return_value_times +debug: removing unused subroutine test_cases.structure_methods.contract.ARC4TestStruct.return1 +debug: removing unused subroutine test_cases.structure_methods.contract.TestStruct.return_value_times +debug: removing unused subroutine test_cases.structure_methods.contract.TestStruct.return1 +debug: removing unused subroutine test_cases.structure_methods.contract.TestNamedTuple.return_value_times +debug: removing unused subroutine test_cases.structure_methods.contract.TestNamedTuple.return1 +debug: removing unused subroutine test_cases.structure_methods.contract.GroupedMethods.never_inlined_usually_inlined +debug: removing unused subroutine test_cases.structure_methods.contract.GroupedMethods.always_inlined_not_usually_inlined +debug: removing unused subroutine test_cases.structure_methods.contract.GroupedMethods.usually_inlined +debug: removing unused subroutine test_cases.structure_methods.contract.GroupedMethods.not_usually_inlined +debug: removing unused subroutine test_cases.structure_methods.contract.TestContract.__puya_arc4_router__ +debug: removing unused subroutine test_cases.structure_methods.contract.TestContract.test[routing] +debug: removing unused subroutine test_cases.structure_methods.contract.TestContract.test +debug: removing unused subroutine test_cases.structure_methods.contract.TestContract.__algopy_default_create +debug: removing unused subroutine algopy.arc4.ARC4Contract.approval_program +debug: removing unused subroutine algopy.arc4.ARC4Contract.clear_state_program +debug: removing unused subroutine algopy._contract.Contract.__init__ +debug: optimizing approval program of test_cases.structure_methods.contract.TestContract at level 0 +debug: Begin optimization pass 1/100 +debug: Optimizing subroutine algopy.arc4.ARC4Contract.approval_program +debug: Optimizer: Perform Subroutine Inlining +debug: inlining call to test_cases.structure_methods.contract.TestContract.__puya_arc4_router__ in algopy.arc4.ARC4Contract.approval_program +debug: Optimizer: Split Parallel Copies +debug: Optimizer: Constant Replacer +debug: Optimizer: Remove Unused Variables +debug: Optimizer: Inner Txn Field Replacer +debug: Optimizer: Replace Compiled References +debug: Optimizer: Merge Chained Aggregate Reads +debug: Optimizer: Replace Aggregate Box Ops +debug: Optimizing subroutine test_cases.structure_methods.contract.ARC4TestStruct.return_value_times +debug: Optimizer: Perform Subroutine Inlining +debug: Optimizer: Split Parallel Copies +debug: Optimizer: Constant Replacer +debug: Optimizer: Remove Unused Variables +debug: Removing unused variable self%is_original#0 +debug: Removing unused variable self%out#0 +debug: Optimizer: Inner Txn Field Replacer +debug: Optimizer: Replace Compiled References +debug: Optimizer: Merge Chained Aggregate Reads +debug: Optimizer: Replace Aggregate Box Ops +debug: Optimizing subroutine test_cases.structure_methods.contract.ARC4TestStruct.return1 +debug: Optimizer: Perform Subroutine Inlining +debug: Optimizer: Split Parallel Copies +debug: Optimizer: Constant Replacer +debug: Optimizer: Remove Unused Variables +debug: Optimizer: Inner Txn Field Replacer +debug: Optimizer: Replace Compiled References +debug: Optimizer: Merge Chained Aggregate Reads +debug: Optimizer: Replace Aggregate Box Ops +debug: Optimizing subroutine test_cases.structure_methods.contract.TestStruct.return_value_times +debug: Optimizer: Perform Subroutine Inlining +debug: Optimizer: Split Parallel Copies +debug: Optimizer: Constant Replacer +debug: Optimizer: Remove Unused Variables +debug: Removing unused variable self%is_original#0 +debug: Removing unused variable self%out#0 +debug: Optimizer: Inner Txn Field Replacer +debug: Optimizer: Replace Compiled References +debug: Optimizer: Merge Chained Aggregate Reads +debug: Optimizer: Replace Aggregate Box Ops +debug: Optimizing subroutine test_cases.structure_methods.contract.TestStruct.return1 +debug: Optimizer: Perform Subroutine Inlining +debug: Optimizer: Split Parallel Copies +debug: Optimizer: Constant Replacer +debug: Optimizer: Remove Unused Variables +debug: Optimizer: Inner Txn Field Replacer +debug: Optimizer: Replace Compiled References +debug: Optimizer: Merge Chained Aggregate Reads +debug: Optimizer: Replace Aggregate Box Ops +debug: Optimizing subroutine test_cases.structure_methods.contract.TestNamedTuple.return_value_times +debug: Optimizer: Perform Subroutine Inlining +debug: Optimizer: Split Parallel Copies +debug: Optimizer: Constant Replacer +debug: Optimizer: Remove Unused Variables +debug: Optimizer: Inner Txn Field Replacer +debug: Optimizer: Replace Compiled References +debug: Optimizer: Merge Chained Aggregate Reads +debug: Optimizer: Replace Aggregate Box Ops +debug: Optimizing subroutine test_cases.structure_methods.contract.TestNamedTuple.return1 +debug: Optimizer: Perform Subroutine Inlining +debug: Optimizer: Split Parallel Copies +debug: Optimizer: Constant Replacer +debug: Optimizer: Remove Unused Variables +debug: Optimizer: Inner Txn Field Replacer +debug: Optimizer: Replace Compiled References +debug: Optimizer: Merge Chained Aggregate Reads +debug: Optimizer: Replace Aggregate Box Ops +debug: Optimizing subroutine test_cases.structure_methods.contract.GroupedMethods.never_inlined_usually_inlined +debug: Optimizer: Perform Subroutine Inlining +debug: Optimizer: Split Parallel Copies +debug: Optimizer: Constant Replacer +debug: Optimizer: Remove Unused Variables +debug: Optimizer: Inner Txn Field Replacer +debug: Optimizer: Replace Compiled References +debug: Optimizer: Merge Chained Aggregate Reads +debug: Optimizer: Replace Aggregate Box Ops +debug: Optimizing subroutine test_cases.structure_methods.contract.GroupedMethods.always_inlined_not_usually_inlined +debug: Optimizer: Perform Subroutine Inlining +debug: Optimizer: Split Parallel Copies +debug: Optimizer: Constant Replacer +debug: Optimizer: Remove Unused Variables +debug: Optimizer: Inner Txn Field Replacer +debug: Optimizer: Replace Compiled References +debug: Optimizer: Merge Chained Aggregate Reads +debug: Optimizer: Replace Aggregate Box Ops +debug: Optimizing subroutine test_cases.structure_methods.contract.GroupedMethods.usually_inlined +debug: Optimizer: Perform Subroutine Inlining +debug: Optimizer: Split Parallel Copies +debug: Optimizer: Constant Replacer +debug: Optimizer: Remove Unused Variables +debug: Optimizer: Inner Txn Field Replacer +debug: Optimizer: Replace Compiled References +debug: Optimizer: Merge Chained Aggregate Reads +debug: Optimizer: Replace Aggregate Box Ops +debug: Optimizing subroutine test_cases.structure_methods.contract.GroupedMethods.not_usually_inlined +debug: Optimizer: Perform Subroutine Inlining +debug: Optimizer: Split Parallel Copies +debug: Optimizer: Constant Replacer +debug: Optimizer: Remove Unused Variables +debug: Optimizer: Inner Txn Field Replacer +debug: Optimizer: Replace Compiled References +debug: Optimizer: Merge Chained Aggregate Reads +debug: Optimizer: Replace Aggregate Box Ops +debug: Optimizing subroutine test_cases.structure_methods.contract.TestContract.__puya_arc4_router__ +debug: Optimizer: Perform Subroutine Inlining +debug: inlining call to test_cases.structure_methods.contract.TestContract.__algopy_default_create in test_cases.structure_methods.contract.TestContract.__puya_arc4_router__ +debug: Optimizer: Split Parallel Copies +debug: Optimizer: Constant Replacer +debug: Optimizer: Remove Unused Variables +debug: Optimizer: Inner Txn Field Replacer +debug: Optimizer: Replace Compiled References +debug: Optimizer: Merge Chained Aggregate Reads +debug: Optimizer: Replace Aggregate Box Ops +debug: Optimizing subroutine test_cases.structure_methods.contract.TestContract.test[routing] +debug: Optimizer: Perform Subroutine Inlining +debug: Optimizer: Split Parallel Copies +debug: Optimizer: Constant Replacer +debug: Optimizer: Remove Unused Variables +debug: Optimizer: Inner Txn Field Replacer +debug: Optimizer: Replace Compiled References +debug: Optimizer: Merge Chained Aggregate Reads +debug: Optimizer: Replace Aggregate Box Ops +debug: Optimizing subroutine test_cases.structure_methods.contract.TestContract.test +debug: Optimizer: Perform Subroutine Inlining +structure_methods/contract.py:105:9 debug: inlining call to test_cases.structure_methods.contract.GroupedMethods.always_inlined_not_usually_inlined in test_cases.structure_methods.contract.TestContract.test +structure_methods/contract.py:106:9 debug: inlining call to test_cases.structure_methods.contract.GroupedMethods.always_inlined_not_usually_inlined in test_cases.structure_methods.contract.TestContract.test +debug: Optimizer: Split Parallel Copies +debug: Optimizer: Constant Replacer +debug: Optimizer: Remove Unused Variables +debug: Removing unused variable v#0 +debug: Removing unused variable v#1 +debug: Optimizer: Inner Txn Field Replacer +debug: Optimizer: Replace Compiled References +debug: Optimizer: Merge Chained Aggregate Reads +debug: Optimizer: Replace Aggregate Box Ops +debug: Optimizing subroutine test_cases.structure_methods.contract.TestContract.__algopy_default_create +debug: Optimizer: Perform Subroutine Inlining +debug: Optimizer: Split Parallel Copies +debug: Optimizer: Constant Replacer +debug: Optimizer: Remove Unused Variables +debug: Optimizer: Inner Txn Field Replacer +debug: Optimizer: Replace Compiled References +debug: Optimizer: Merge Chained Aggregate Reads +debug: Optimizer: Replace Aggregate Box Ops +debug: removing unused subroutine test_cases.structure_methods.contract.GroupedMethods.always_inlined_not_usually_inlined +debug: removing unused subroutine test_cases.structure_methods.contract.TestContract.__puya_arc4_router__ +debug: Unused subroutines removed +debug: Begin optimization pass 2/100 +debug: Optimizing subroutine algopy.arc4.ARC4Contract.approval_program +debug: Optimizer: Perform Subroutine Inlining +debug: inlining call to test_cases.structure_methods.contract.TestContract.__algopy_default_create in algopy.arc4.ARC4Contract.approval_program +debug: Optimizer: Split Parallel Copies +debug: Optimizer: Constant Replacer +debug: Optimizer: Remove Unused Variables +debug: Optimizer: Inner Txn Field Replacer +debug: Optimizer: Replace Compiled References +debug: Optimizer: Merge Chained Aggregate Reads +debug: Optimizer: Replace Aggregate Box Ops +debug: Optimizing subroutine test_cases.structure_methods.contract.ARC4TestStruct.return_value_times +debug: Optimizer: Perform Subroutine Inlining +debug: Optimizer: Split Parallel Copies +debug: Optimizer: Constant Replacer +debug: Optimizer: Remove Unused Variables +debug: Optimizer: Inner Txn Field Replacer +debug: Optimizer: Replace Compiled References +debug: Optimizer: Merge Chained Aggregate Reads +debug: Optimizer: Replace Aggregate Box Ops +debug: Optimizing subroutine test_cases.structure_methods.contract.ARC4TestStruct.return1 +debug: Optimizer: Perform Subroutine Inlining +debug: Optimizer: Split Parallel Copies +debug: Optimizer: Constant Replacer +debug: Optimizer: Remove Unused Variables +debug: Optimizer: Inner Txn Field Replacer +debug: Optimizer: Replace Compiled References +debug: Optimizer: Merge Chained Aggregate Reads +debug: Optimizer: Replace Aggregate Box Ops +debug: Optimizing subroutine test_cases.structure_methods.contract.TestStruct.return_value_times +debug: Optimizer: Perform Subroutine Inlining +debug: Optimizer: Split Parallel Copies +debug: Optimizer: Constant Replacer +debug: Optimizer: Remove Unused Variables +debug: Optimizer: Inner Txn Field Replacer +debug: Optimizer: Replace Compiled References +debug: Optimizer: Merge Chained Aggregate Reads +debug: Optimizer: Replace Aggregate Box Ops +debug: Optimizing subroutine test_cases.structure_methods.contract.TestStruct.return1 +debug: Optimizer: Perform Subroutine Inlining +debug: Optimizer: Split Parallel Copies +debug: Optimizer: Constant Replacer +debug: Optimizer: Remove Unused Variables +debug: Optimizer: Inner Txn Field Replacer +debug: Optimizer: Replace Compiled References +debug: Optimizer: Merge Chained Aggregate Reads +debug: Optimizer: Replace Aggregate Box Ops +debug: Optimizing subroutine test_cases.structure_methods.contract.TestNamedTuple.return_value_times +debug: Optimizer: Perform Subroutine Inlining +debug: Optimizer: Split Parallel Copies +debug: Optimizer: Constant Replacer +debug: Optimizer: Remove Unused Variables +debug: Optimizer: Inner Txn Field Replacer +debug: Optimizer: Replace Compiled References +debug: Optimizer: Merge Chained Aggregate Reads +debug: Optimizer: Replace Aggregate Box Ops +debug: Optimizing subroutine test_cases.structure_methods.contract.TestNamedTuple.return1 +debug: Optimizer: Perform Subroutine Inlining +debug: Optimizer: Split Parallel Copies +debug: Optimizer: Constant Replacer +debug: Optimizer: Remove Unused Variables +debug: Optimizer: Inner Txn Field Replacer +debug: Optimizer: Replace Compiled References +debug: Optimizer: Merge Chained Aggregate Reads +debug: Optimizer: Replace Aggregate Box Ops +debug: Optimizing subroutine test_cases.structure_methods.contract.GroupedMethods.never_inlined_usually_inlined +debug: Optimizer: Perform Subroutine Inlining +debug: Optimizer: Split Parallel Copies +debug: Optimizer: Constant Replacer +debug: Optimizer: Remove Unused Variables +debug: Optimizer: Inner Txn Field Replacer +debug: Optimizer: Replace Compiled References +debug: Optimizer: Merge Chained Aggregate Reads +debug: Optimizer: Replace Aggregate Box Ops +debug: Optimizing subroutine test_cases.structure_methods.contract.GroupedMethods.usually_inlined +debug: Optimizer: Perform Subroutine Inlining +debug: Optimizer: Split Parallel Copies +debug: Optimizer: Constant Replacer +debug: Optimizer: Remove Unused Variables +debug: Optimizer: Inner Txn Field Replacer +debug: Optimizer: Replace Compiled References +debug: Optimizer: Merge Chained Aggregate Reads +debug: Optimizer: Replace Aggregate Box Ops +debug: Optimizing subroutine test_cases.structure_methods.contract.GroupedMethods.not_usually_inlined +debug: Optimizer: Perform Subroutine Inlining +debug: Optimizer: Split Parallel Copies +debug: Optimizer: Constant Replacer +debug: Optimizer: Remove Unused Variables +debug: Optimizer: Inner Txn Field Replacer +debug: Optimizer: Replace Compiled References +debug: Optimizer: Merge Chained Aggregate Reads +debug: Optimizer: Replace Aggregate Box Ops +debug: Optimizing subroutine test_cases.structure_methods.contract.TestContract.test[routing] +debug: Optimizer: Perform Subroutine Inlining +debug: Optimizer: Split Parallel Copies +debug: Optimizer: Constant Replacer +debug: Optimizer: Remove Unused Variables +debug: Optimizer: Inner Txn Field Replacer +debug: Optimizer: Replace Compiled References +debug: Optimizer: Merge Chained Aggregate Reads +debug: Optimizer: Replace Aggregate Box Ops +debug: Optimizing subroutine test_cases.structure_methods.contract.TestContract.test +debug: Optimizer: Perform Subroutine Inlining +debug: Optimizer: Split Parallel Copies +debug: Optimizer: Constant Replacer +debug: Optimizer: Remove Unused Variables +debug: Optimizer: Inner Txn Field Replacer +debug: Optimizer: Replace Compiled References +debug: Optimizer: Merge Chained Aggregate Reads +debug: Optimizer: Replace Aggregate Box Ops +debug: Optimizing subroutine test_cases.structure_methods.contract.TestContract.__algopy_default_create +debug: Optimizer: Perform Subroutine Inlining +debug: Optimizer: Split Parallel Copies +debug: Optimizer: Constant Replacer +debug: Optimizer: Remove Unused Variables +debug: Optimizer: Inner Txn Field Replacer +debug: Optimizer: Replace Compiled References +debug: Optimizer: Merge Chained Aggregate Reads +debug: Optimizer: Replace Aggregate Box Ops +debug: removing unused subroutine test_cases.structure_methods.contract.TestContract.__algopy_default_create +debug: Unused subroutines removed +debug: Begin optimization pass 3/100 +debug: Optimizing subroutine algopy.arc4.ARC4Contract.approval_program +debug: Optimizer: Perform Subroutine Inlining +debug: Optimizer: Split Parallel Copies +debug: Optimizer: Constant Replacer +debug: Optimizer: Remove Unused Variables +debug: Optimizer: Inner Txn Field Replacer +debug: Optimizer: Replace Compiled References +debug: Optimizer: Merge Chained Aggregate Reads +debug: Optimizer: Replace Aggregate Box Ops +debug: Optimizing subroutine test_cases.structure_methods.contract.ARC4TestStruct.return_value_times +debug: Optimizer: Perform Subroutine Inlining +debug: Optimizer: Split Parallel Copies +debug: Optimizer: Constant Replacer +debug: Optimizer: Remove Unused Variables +debug: Optimizer: Inner Txn Field Replacer +debug: Optimizer: Replace Compiled References +debug: Optimizer: Merge Chained Aggregate Reads +debug: Optimizer: Replace Aggregate Box Ops +debug: Optimizing subroutine test_cases.structure_methods.contract.ARC4TestStruct.return1 +debug: Optimizer: Perform Subroutine Inlining +debug: Optimizer: Split Parallel Copies +debug: Optimizer: Constant Replacer +debug: Optimizer: Remove Unused Variables +debug: Optimizer: Inner Txn Field Replacer +debug: Optimizer: Replace Compiled References +debug: Optimizer: Merge Chained Aggregate Reads +debug: Optimizer: Replace Aggregate Box Ops +debug: Optimizing subroutine test_cases.structure_methods.contract.TestStruct.return_value_times +debug: Optimizer: Perform Subroutine Inlining +debug: Optimizer: Split Parallel Copies +debug: Optimizer: Constant Replacer +debug: Optimizer: Remove Unused Variables +debug: Optimizer: Inner Txn Field Replacer +debug: Optimizer: Replace Compiled References +debug: Optimizer: Merge Chained Aggregate Reads +debug: Optimizer: Replace Aggregate Box Ops +debug: Optimizing subroutine test_cases.structure_methods.contract.TestStruct.return1 +debug: Optimizer: Perform Subroutine Inlining +debug: Optimizer: Split Parallel Copies +debug: Optimizer: Constant Replacer +debug: Optimizer: Remove Unused Variables +debug: Optimizer: Inner Txn Field Replacer +debug: Optimizer: Replace Compiled References +debug: Optimizer: Merge Chained Aggregate Reads +debug: Optimizer: Replace Aggregate Box Ops +debug: Optimizing subroutine test_cases.structure_methods.contract.TestNamedTuple.return_value_times +debug: Optimizer: Perform Subroutine Inlining +debug: Optimizer: Split Parallel Copies +debug: Optimizer: Constant Replacer +debug: Optimizer: Remove Unused Variables +debug: Optimizer: Inner Txn Field Replacer +debug: Optimizer: Replace Compiled References +debug: Optimizer: Merge Chained Aggregate Reads +debug: Optimizer: Replace Aggregate Box Ops +debug: Optimizing subroutine test_cases.structure_methods.contract.TestNamedTuple.return1 +debug: Optimizer: Perform Subroutine Inlining +debug: Optimizer: Split Parallel Copies +debug: Optimizer: Constant Replacer +debug: Optimizer: Remove Unused Variables +debug: Optimizer: Inner Txn Field Replacer +debug: Optimizer: Replace Compiled References +debug: Optimizer: Merge Chained Aggregate Reads +debug: Optimizer: Replace Aggregate Box Ops +debug: Optimizing subroutine test_cases.structure_methods.contract.GroupedMethods.never_inlined_usually_inlined +debug: Optimizer: Perform Subroutine Inlining +debug: Optimizer: Split Parallel Copies +debug: Optimizer: Constant Replacer +debug: Optimizer: Remove Unused Variables +debug: Optimizer: Inner Txn Field Replacer +debug: Optimizer: Replace Compiled References +debug: Optimizer: Merge Chained Aggregate Reads +debug: Optimizer: Replace Aggregate Box Ops +debug: Optimizing subroutine test_cases.structure_methods.contract.GroupedMethods.usually_inlined +debug: Optimizer: Perform Subroutine Inlining +debug: Optimizer: Split Parallel Copies +debug: Optimizer: Constant Replacer +debug: Optimizer: Remove Unused Variables +debug: Optimizer: Inner Txn Field Replacer +debug: Optimizer: Replace Compiled References +debug: Optimizer: Merge Chained Aggregate Reads +debug: Optimizer: Replace Aggregate Box Ops +debug: Optimizing subroutine test_cases.structure_methods.contract.GroupedMethods.not_usually_inlined +debug: Optimizer: Perform Subroutine Inlining +debug: Optimizer: Split Parallel Copies +debug: Optimizer: Constant Replacer +debug: Optimizer: Remove Unused Variables +debug: Optimizer: Inner Txn Field Replacer +debug: Optimizer: Replace Compiled References +debug: Optimizer: Merge Chained Aggregate Reads +debug: Optimizer: Replace Aggregate Box Ops +debug: Optimizing subroutine test_cases.structure_methods.contract.TestContract.test[routing] +debug: Optimizer: Perform Subroutine Inlining +debug: Optimizer: Split Parallel Copies +debug: Optimizer: Constant Replacer +debug: Optimizer: Remove Unused Variables +debug: Optimizer: Inner Txn Field Replacer +debug: Optimizer: Replace Compiled References +debug: Optimizer: Merge Chained Aggregate Reads +debug: Optimizer: Replace Aggregate Box Ops +debug: Optimizing subroutine test_cases.structure_methods.contract.TestContract.test +debug: Optimizer: Perform Subroutine Inlining +debug: Optimizer: Split Parallel Copies +debug: Optimizer: Constant Replacer +debug: Optimizer: Remove Unused Variables +debug: Optimizer: Inner Txn Field Replacer +debug: Optimizer: Replace Compiled References +debug: Optimizer: Merge Chained Aggregate Reads +debug: Optimizer: Replace Aggregate Box Ops +debug: No optimizations performed in pass 3, ending loop +debug: optimizing clear program of test_cases.structure_methods.contract.TestContract at level 0 +debug: Begin optimization pass 1/100 +debug: Optimizing subroutine algopy.arc4.ARC4Contract.clear_state_program +debug: Optimizer: Perform Subroutine Inlining +debug: Optimizer: Split Parallel Copies +debug: Optimizer: Constant Replacer +debug: Optimizer: Remove Unused Variables +debug: Optimizer: Inner Txn Field Replacer +debug: Optimizer: Replace Compiled References +debug: Optimizer: Merge Chained Aggregate Reads +debug: Optimizer: Replace Aggregate Box Ops +debug: No optimizations performed in pass 1, ending loop +debug: lowering array IR nodes in approval program of test_cases.structure_methods.contract.TestContract +debug: lowering array IR nodes in clear program of test_cases.structure_methods.contract.TestContract +debug: optimizing approval program of test_cases.structure_methods.contract.TestContract at level 0 +debug: Begin optimization pass 1/100 +debug: Optimizing subroutine algopy.arc4.ARC4Contract.approval_program +debug: Optimizer: Perform Subroutine Inlining +debug: Optimizer: Split Parallel Copies +debug: Optimizer: Constant Replacer +debug: Optimizer: Remove Unused Variables +debug: Optimizer: Inner Txn Field Replacer +debug: Optimizer: Replace Compiled References +debug: Optimizer: Merge Chained Aggregate Reads +debug: Optimizer: Replace Aggregate Box Ops +debug: Optimizing subroutine test_cases.structure_methods.contract.ARC4TestStruct.return_value_times +debug: Optimizer: Perform Subroutine Inlining +debug: Optimizer: Split Parallel Copies +debug: Optimizer: Constant Replacer +debug: Optimizer: Remove Unused Variables +debug: Optimizer: Inner Txn Field Replacer +debug: Optimizer: Replace Compiled References +debug: Optimizer: Merge Chained Aggregate Reads +debug: Optimizer: Replace Aggregate Box Ops +debug: Optimizing subroutine test_cases.structure_methods.contract.ARC4TestStruct.return1 +debug: Optimizer: Perform Subroutine Inlining +debug: Optimizer: Split Parallel Copies +debug: Optimizer: Constant Replacer +debug: Optimizer: Remove Unused Variables +debug: Optimizer: Inner Txn Field Replacer +debug: Optimizer: Replace Compiled References +debug: Optimizer: Merge Chained Aggregate Reads +debug: Optimizer: Replace Aggregate Box Ops +debug: Optimizing subroutine test_cases.structure_methods.contract.TestStruct.return_value_times +debug: Optimizer: Perform Subroutine Inlining +debug: Optimizer: Split Parallel Copies +debug: Optimizer: Constant Replacer +debug: Optimizer: Remove Unused Variables +debug: Optimizer: Inner Txn Field Replacer +debug: Optimizer: Replace Compiled References +debug: Optimizer: Merge Chained Aggregate Reads +debug: Optimizer: Replace Aggregate Box Ops +debug: Optimizing subroutine test_cases.structure_methods.contract.TestStruct.return1 +debug: Optimizer: Perform Subroutine Inlining +debug: Optimizer: Split Parallel Copies +debug: Optimizer: Constant Replacer +debug: Optimizer: Remove Unused Variables +debug: Optimizer: Inner Txn Field Replacer +debug: Optimizer: Replace Compiled References +debug: Optimizer: Merge Chained Aggregate Reads +debug: Optimizer: Replace Aggregate Box Ops +debug: Optimizing subroutine test_cases.structure_methods.contract.TestNamedTuple.return_value_times +debug: Optimizer: Perform Subroutine Inlining +debug: Optimizer: Split Parallel Copies +debug: Optimizer: Constant Replacer +debug: Optimizer: Remove Unused Variables +debug: Optimizer: Inner Txn Field Replacer +debug: Optimizer: Replace Compiled References +debug: Optimizer: Merge Chained Aggregate Reads +debug: Optimizer: Replace Aggregate Box Ops +debug: Optimizing subroutine test_cases.structure_methods.contract.TestNamedTuple.return1 +debug: Optimizer: Perform Subroutine Inlining +debug: Optimizer: Split Parallel Copies +debug: Optimizer: Constant Replacer +debug: Optimizer: Remove Unused Variables +debug: Optimizer: Inner Txn Field Replacer +debug: Optimizer: Replace Compiled References +debug: Optimizer: Merge Chained Aggregate Reads +debug: Optimizer: Replace Aggregate Box Ops +debug: Optimizing subroutine test_cases.structure_methods.contract.GroupedMethods.never_inlined_usually_inlined +debug: Optimizer: Perform Subroutine Inlining +debug: Optimizer: Split Parallel Copies +debug: Optimizer: Constant Replacer +debug: Optimizer: Remove Unused Variables +debug: Optimizer: Inner Txn Field Replacer +debug: Optimizer: Replace Compiled References +debug: Optimizer: Merge Chained Aggregate Reads +debug: Optimizer: Replace Aggregate Box Ops +debug: Optimizing subroutine test_cases.structure_methods.contract.GroupedMethods.usually_inlined +debug: Optimizer: Perform Subroutine Inlining +debug: Optimizer: Split Parallel Copies +debug: Optimizer: Constant Replacer +debug: Optimizer: Remove Unused Variables +debug: Optimizer: Inner Txn Field Replacer +debug: Optimizer: Replace Compiled References +debug: Optimizer: Merge Chained Aggregate Reads +debug: Optimizer: Replace Aggregate Box Ops +debug: Optimizing subroutine test_cases.structure_methods.contract.GroupedMethods.not_usually_inlined +debug: Optimizer: Perform Subroutine Inlining +debug: Optimizer: Split Parallel Copies +debug: Optimizer: Constant Replacer +debug: Optimizer: Remove Unused Variables +debug: Optimizer: Inner Txn Field Replacer +debug: Optimizer: Replace Compiled References +debug: Optimizer: Merge Chained Aggregate Reads +debug: Optimizer: Replace Aggregate Box Ops +debug: Optimizing subroutine test_cases.structure_methods.contract.TestContract.test[routing] +debug: Optimizer: Perform Subroutine Inlining +debug: Optimizer: Split Parallel Copies +debug: Optimizer: Constant Replacer +debug: Optimizer: Remove Unused Variables +debug: Optimizer: Inner Txn Field Replacer +debug: Optimizer: Replace Compiled References +debug: Optimizer: Merge Chained Aggregate Reads +debug: Optimizer: Replace Aggregate Box Ops +debug: Optimizing subroutine test_cases.structure_methods.contract.TestContract.test +debug: Optimizer: Perform Subroutine Inlining +debug: Optimizer: Split Parallel Copies +debug: Optimizer: Constant Replacer +debug: Optimizer: Remove Unused Variables +debug: Optimizer: Inner Txn Field Replacer +debug: Optimizer: Replace Compiled References +debug: Optimizer: Merge Chained Aggregate Reads +debug: Optimizer: Replace Aggregate Box Ops +debug: No optimizations performed in pass 1, ending loop +debug: optimizing clear program of test_cases.structure_methods.contract.TestContract at level 0 +debug: Begin optimization pass 1/100 +debug: Optimizing subroutine algopy.arc4.ARC4Contract.clear_state_program +debug: Optimizer: Perform Subroutine Inlining +debug: Optimizer: Split Parallel Copies +debug: Optimizer: Constant Replacer +debug: Optimizer: Remove Unused Variables +debug: Optimizer: Inner Txn Field Replacer +debug: Optimizer: Replace Compiled References +debug: Optimizer: Merge Chained Aggregate Reads +debug: Optimizer: Replace Aggregate Box Ops +debug: No optimizations performed in pass 1, ending loop +debug: removing local static slots in approval program of test_cases.structure_methods.contract.TestContract +debug: auto reserving slots in algopy.arc4.ARC4Contract.approval_program, [] +structure_methods/contract.py:9:5 debug: auto reserving slots in test_cases.structure_methods.contract.ARC4TestStruct.return_value_times, [] +structure_methods/contract.py:12:6 debug: auto reserving slots in test_cases.structure_methods.contract.ARC4TestStruct.return1, [] +structure_methods/contract.py:20:5 debug: auto reserving slots in test_cases.structure_methods.contract.TestStruct.return_value_times, [] +structure_methods/contract.py:23:6 debug: auto reserving slots in test_cases.structure_methods.contract.TestStruct.return1, [] +structure_methods/contract.py:31:5 debug: auto reserving slots in test_cases.structure_methods.contract.TestNamedTuple.return_value_times, [] +structure_methods/contract.py:34:6 debug: auto reserving slots in test_cases.structure_methods.contract.TestNamedTuple.return1, [] +structure_methods/contract.py:40:6 debug: auto reserving slots in test_cases.structure_methods.contract.GroupedMethods.never_inlined_usually_inlined, [] +structure_methods/contract.py:55:5 debug: auto reserving slots in test_cases.structure_methods.contract.GroupedMethods.usually_inlined, [] +structure_methods/contract.py:58:5 debug: auto reserving slots in test_cases.structure_methods.contract.GroupedMethods.not_usually_inlined, [] +structure_methods/contract.py:70:6 debug: auto reserving slots in test_cases.structure_methods.contract.TestContract.test[routing], [] +structure_methods/contract.py:70:6 debug: auto reserving slots in test_cases.structure_methods.contract.TestContract.test, [] +debug: Slot allocation not required +debug: removing local static slots in clear program of test_cases.structure_methods.contract.TestContract +debug: auto reserving slots in algopy.arc4.ARC4Contract.clear_state_program, [] +debug: Slot allocation not required +debug: Performing SSA IR destructuring for algopy.arc4.ARC4Contract.approval_program +debug: Converting to CSSA +debug: Removing Phi nodes +debug: Coalescing local variables in algopy.arc4.ARC4Contract.approval_program using strategy 'root_operand' +debug: Coalescing resulted in 0 replacement/s +debug: Sequentializing parallel copies in algopy.arc4.ARC4Contract.approval_program +debug: Performing post-SSA optimizations at level 0 +debug: Performing SSA IR destructuring for test_cases.structure_methods.contract.ARC4TestStruct.return_value_times +debug: Converting to CSSA +debug: Removing Phi nodes +debug: Coalescing local variables in test_cases.structure_methods.contract.ARC4TestStruct.return_value_times using strategy 'root_operand' +debug: Coalescing resulted in 0 replacement/s +debug: Sequentializing parallel copies in test_cases.structure_methods.contract.ARC4TestStruct.return_value_times +debug: Performing post-SSA optimizations at level 0 +debug: Performing SSA IR destructuring for test_cases.structure_methods.contract.ARC4TestStruct.return1 +debug: Converting to CSSA +debug: Removing Phi nodes +debug: Coalescing local variables in test_cases.structure_methods.contract.ARC4TestStruct.return1 using strategy 'root_operand' +debug: Coalescing resulted in 0 replacement/s +debug: Sequentializing parallel copies in test_cases.structure_methods.contract.ARC4TestStruct.return1 +debug: Performing post-SSA optimizations at level 0 +debug: Performing SSA IR destructuring for test_cases.structure_methods.contract.TestStruct.return_value_times +debug: Converting to CSSA +debug: Removing Phi nodes +debug: Coalescing local variables in test_cases.structure_methods.contract.TestStruct.return_value_times using strategy 'root_operand' +debug: Coalescing resulted in 0 replacement/s +debug: Sequentializing parallel copies in test_cases.structure_methods.contract.TestStruct.return_value_times +debug: Performing post-SSA optimizations at level 0 +debug: Performing SSA IR destructuring for test_cases.structure_methods.contract.TestStruct.return1 +debug: Converting to CSSA +debug: Removing Phi nodes +debug: Coalescing local variables in test_cases.structure_methods.contract.TestStruct.return1 using strategy 'root_operand' +debug: Coalescing resulted in 0 replacement/s +debug: Sequentializing parallel copies in test_cases.structure_methods.contract.TestStruct.return1 +debug: Performing post-SSA optimizations at level 0 +debug: Performing SSA IR destructuring for test_cases.structure_methods.contract.TestNamedTuple.return_value_times +debug: Converting to CSSA +debug: Removing Phi nodes +debug: Coalescing local variables in test_cases.structure_methods.contract.TestNamedTuple.return_value_times using strategy 'root_operand' +debug: Coalescing resulted in 0 replacement/s +debug: Sequentializing parallel copies in test_cases.structure_methods.contract.TestNamedTuple.return_value_times +debug: Performing post-SSA optimizations at level 0 +debug: Performing SSA IR destructuring for test_cases.structure_methods.contract.TestNamedTuple.return1 +debug: Converting to CSSA +debug: Removing Phi nodes +debug: Coalescing local variables in test_cases.structure_methods.contract.TestNamedTuple.return1 using strategy 'root_operand' +debug: Coalescing resulted in 0 replacement/s +debug: Sequentializing parallel copies in test_cases.structure_methods.contract.TestNamedTuple.return1 +debug: Performing post-SSA optimizations at level 0 +debug: Performing SSA IR destructuring for test_cases.structure_methods.contract.GroupedMethods.never_inlined_usually_inlined +debug: Converting to CSSA +debug: Removing Phi nodes +debug: Coalescing local variables in test_cases.structure_methods.contract.GroupedMethods.never_inlined_usually_inlined using strategy 'root_operand' +debug: Coalescing resulted in 0 replacement/s +debug: Sequentializing parallel copies in test_cases.structure_methods.contract.GroupedMethods.never_inlined_usually_inlined +debug: Performing post-SSA optimizations at level 0 +debug: Performing SSA IR destructuring for test_cases.structure_methods.contract.GroupedMethods.usually_inlined +debug: Converting to CSSA +debug: Removing Phi nodes +debug: Coalescing local variables in test_cases.structure_methods.contract.GroupedMethods.usually_inlined using strategy 'root_operand' +debug: Coalescing resulted in 0 replacement/s +debug: Sequentializing parallel copies in test_cases.structure_methods.contract.GroupedMethods.usually_inlined +debug: Performing post-SSA optimizations at level 0 +debug: Performing SSA IR destructuring for test_cases.structure_methods.contract.GroupedMethods.not_usually_inlined +debug: Converting to CSSA +debug: Removing Phi nodes +debug: Coalescing local variables in test_cases.structure_methods.contract.GroupedMethods.not_usually_inlined using strategy 'root_operand' +debug: Coalescing resulted in 0 replacement/s +debug: Sequentializing parallel copies in test_cases.structure_methods.contract.GroupedMethods.not_usually_inlined +debug: Performing post-SSA optimizations at level 0 +debug: Performing SSA IR destructuring for test_cases.structure_methods.contract.TestContract.test[routing] +debug: Converting to CSSA +debug: Removing Phi nodes +debug: Coalescing local variables in test_cases.structure_methods.contract.TestContract.test[routing] using strategy 'root_operand' +debug: Coalescing resulted in 0 replacement/s +debug: Sequentializing parallel copies in test_cases.structure_methods.contract.TestContract.test[routing] +debug: Performing post-SSA optimizations at level 0 +debug: Performing SSA IR destructuring for test_cases.structure_methods.contract.TestContract.test +debug: Converting to CSSA +debug: Removing Phi nodes +debug: Coalescing local variables in test_cases.structure_methods.contract.TestContract.test using strategy 'root_operand' +debug: Coalescing tmp%0#0 with [tmp%0#0, tmp%0#1, tmp%0#2] +debug: Coalescing tmp%2#0 with [tmp%2#0, tmp%2#1, tmp%2#2] +debug: Coalescing tmp%6#0 with [tmp%6#0, tmp%6#1, tmp%6#2] +debug: Coalescing tmp%8#0 with [tmp%8#0, tmp%8#1, tmp%8#2] +debug: Coalescing tmp%1#1 with [tmp%1#2] +debug: Coalescing event%0#0 with [event%0#1] +debug: Coalescing tmp%3#1 with [tmp%3#2] +debug: Coalescing event%1#0 with [event%1#1] +debug: Coalescing tmp%4#1 with [tmp%4#2] +debug: Coalescing tmp%5#1 with [tmp%5#2] +debug: Coalescing event%2#0 with [event%2#1] +debug: Coalescing tmp%7#1 with [tmp%7#2] +debug: Coalescing event%3#0 with [event%3#1] +debug: Coalescing tmp%9#1 with [tmp%9#2] +debug: Coalescing event%4#0 with [event%4#1] +debug: Coalescing tmp%10#1 with [tmp%10#2] +debug: Coalescing tmp%11#1 with [tmp%11#2] +debug: Coalescing event%5#0 with [event%5#1] +debug: Coalescing tmp%12#1 with [tmp%12#2] +debug: Coalescing tmp%13#1 with [tmp%13#2] +debug: Coalescing event%6#0 with [event%6#1] +debug: Coalescing tmp%14#1 with [tmp%14#2] +debug: Coalescing tmp%15#1 with [tmp%15#2] +debug: Coalescing event%7#0 with [event%7#1] +debug: Coalescing resulted in 64 replacement/s +debug: Sequentializing parallel copies in test_cases.structure_methods.contract.TestContract.test +debug: Performing post-SSA optimizations at level 0 +debug: Output IR to structure_methods/out_unoptimized/TestContract.ir/TestContract.approval.400.destructured.ir +debug: Performing SSA IR destructuring for algopy.arc4.ARC4Contract.clear_state_program +debug: Converting to CSSA +debug: Removing Phi nodes +debug: Coalescing local variables in algopy.arc4.ARC4Contract.clear_state_program using strategy 'root_operand' +debug: Coalescing resulted in 0 replacement/s +debug: Sequentializing parallel copies in algopy.arc4.ARC4Contract.clear_state_program +debug: Performing post-SSA optimizations at level 0 +debug: Output IR to structure_methods/out_unoptimized/TestContract.ir/TestContract.clear.400.destructured.ir +debug: Inserted main_block@1.ops[1]: 'l-store-copy tmp%0#1 0' +debug: Replaced main_block@1.ops[3]: 'v-load tmp%0#1' with 'l-load tmp%0#1' +debug: Inserted main_block@1.ops[6]: 'l-store-copy tmp%1#0 0' +debug: Replaced main_block@1.ops[8]: 'v-load tmp%1#0' with 'l-load tmp%1#0' +debug: Inserted main_abi_routing@2.ops[1]: 'l-store-copy tmp%2#0 0' +debug: Replaced main_abi_routing@2.ops[4]: 'v-load tmp%2#0' with 'l-load tmp%2#0' +debug: Inserted main_test_route@3.ops[1]: 'l-store-copy tmp%3#0 0' +debug: Replaced main_test_route@3.ops[3]: 'v-load tmp%3#0' with 'l-load tmp%3#0' +debug: Inserted main_test_route@3.ops[8]: 'l-store-copy tmp%5#0 0' +debug: Replaced main_test_route@3.ops[10]: 'v-load tmp%5#0' with 'l-load tmp%5#0' +debug: Inserted main_test_route@3.ops[17]: 'l-store-copy tmp%7#0 0' +debug: Replaced main_test_route@3.ops[19]: 'v-load tmp%7#0' with 'l-load tmp%7#0' +debug: Inserted main_test_route@3.ops[13]: 'l-store-copy tmp%6#0 0' +debug: Replaced main_test_route@3.ops[16]: 'v-load tmp%6#0' with 'l-load tmp%6#0' +debug: Inserted main_test_route@3.ops[6]: 'l-store-copy tmp%4#0 0' +debug: Replaced main_test_route@3.ops[16]: 'v-load tmp%4#0' with 'l-load tmp%4#0' +debug: Inserted main___algopy_default_create@5.ops[1]: 'l-store-copy tmp%8#0 0' +debug: Replaced main___algopy_default_create@5.ops[3]: 'v-load tmp%8#0' with 'l-load tmp%8#0' +debug: Inserted main___algopy_default_create@5.ops[8]: 'l-store-copy tmp%10#0 0' +debug: Replaced main___algopy_default_create@5.ops[10]: 'v-load tmp%10#0' with 'l-load tmp%10#0' +debug: Inserted main___algopy_default_create@5.ops[17]: 'l-store-copy tmp%12#0 0' +debug: Replaced main___algopy_default_create@5.ops[19]: 'v-load tmp%12#0' with 'l-load tmp%12#0' +debug: Inserted main___algopy_default_create@5.ops[13]: 'l-store-copy tmp%11#0 0' +debug: Replaced main___algopy_default_create@5.ops[16]: 'v-load tmp%11#0' with 'l-load tmp%11#0' +debug: Inserted main___algopy_default_create@5.ops[6]: 'l-store-copy tmp%9#0 0' +debug: Replaced main___algopy_default_create@5.ops[16]: 'v-load tmp%9#0' with 'l-load tmp%9#0' +debug: Inserted main_after_inlined_test_cases.structure_methods.contract.TestContract.__puya_arc4_router__@7.ops[1]: 'l-store-copy tmp%0#0 0' +debug: Replaced main_after_inlined_test_cases.structure_methods.contract.TestContract.__puya_arc4_router__@7.ops[3]: 'v-load tmp%0#0' with 'l-load tmp%0#0' +debug: Inserted return_value_times_block@0.ops[4]: 'l-store-copy aggregate%extract%0#0 0' +debug: Replaced return_value_times_block@0.ops[6]: 'v-load aggregate%extract%0#0' with 'l-load aggregate%extract%0#0' +debug: Inserted return_value_times_block@0.ops[7]: 'l-store-copy tuple_item%0#0 0' +debug: Replaced return_value_times_block@0.ops[9]: 'v-load tuple_item%0#0' with 'l-load tuple_item%0#0' +debug: Inserted return_value_times_block@0.ops[11]: 'l-store-copy tmp%0#0 0' +debug: Replaced return_value_times_block@0.ops[13]: 'v-load tmp%0#0' with 'l-load tmp%0#0' +debug: Inserted return_value_times_block@0.ops[16]: 'l-store-copy tmp%1#0 0' +debug: Replaced return_value_times_block@0.ops[18]: 'v-load tmp%1#0' with 'l-load tmp%1#0' +debug: Inserted test_cases.structure_methods.contract.TestStruct.return_value_times_block@0.ops[4]: 'l-store-copy aggregate%extract%0#0 0' +debug: Replaced test_cases.structure_methods.contract.TestStruct.return_value_times_block@0.ops[6]: 'v-load aggregate%extract%0#0' with 'l-load aggregate%extract%0#0' +debug: Inserted test_cases.structure_methods.contract.TestStruct.return_value_times_block@0.ops[7]: 'l-store-copy tuple_item%0#0 0' +debug: Replaced test_cases.structure_methods.contract.TestStruct.return_value_times_block@0.ops[9]: 'v-load tuple_item%0#0' with 'l-load tuple_item%0#0' +debug: Inserted test_cases.structure_methods.contract.TestStruct.return_value_times_block@0.ops[11]: 'l-store-copy values%0#0 0' +debug: Replaced test_cases.structure_methods.contract.TestStruct.return_value_times_block@0.ops[13]: 'v-load values%0#0' with 'l-load values%0#0' +debug: Inserted test_cases.structure_methods.contract.TestStruct.return_value_times_block@0.ops[16]: 'l-store-copy tmp%0#0 0' +debug: Replaced test_cases.structure_methods.contract.TestStruct.return_value_times_block@0.ops[18]: 'v-load tmp%0#0' with 'l-load tmp%0#0' +debug: Inserted test_cases.structure_methods.contract.TestNamedTuple.return_value_times_block@0.ops[3]: 'l-store-copy tmp%0#0 0' +debug: Replaced test_cases.structure_methods.contract.TestNamedTuple.return_value_times_block@0.ops[5]: 'v-load tmp%0#0' with 'l-load tmp%0#0' +debug: Inserted never_inlined_usually_inlined_block@0.ops[3]: 'l-store-copy tmp%0#0 0' +debug: Replaced never_inlined_usually_inlined_block@0.ops[5]: 'v-load tmp%0#0' with 'l-load tmp%0#0' +debug: Inserted usually_inlined_block@0.ops[3]: 'l-store-copy tmp%0#0 0' +debug: Replaced usually_inlined_block@0.ops[5]: 'v-load tmp%0#0' with 'l-load tmp%0#0' +debug: Inserted not_usually_inlined_block@0.ops[2]: 'l-store-copy aggregate%val_as_bytes%0#0 0' +debug: Replaced not_usually_inlined_block@0.ops[4]: 'v-load aggregate%val_as_bytes%0#0' with 'l-load aggregate%val_as_bytes%0#0' +debug: Inserted not_usually_inlined_block@0.ops[5]: 'l-store-copy aggregate%as_Encoded(uint64)%0#0 0' +debug: Replaced not_usually_inlined_block@0.ops[7]: 'v-load aggregate%as_Encoded(uint64)%0#0' with 'l-load aggregate%as_Encoded(uint64)%0#0' +debug: Inserted not_usually_inlined_block@0.ops[12]: 'l-store-copy aggregate%head%0#0 0' +debug: Replaced not_usually_inlined_block@0.ops[14]: 'v-load aggregate%head%0#0' with 'l-load aggregate%head%0#0' +debug: Inserted not_usually_inlined_block@0.ops[15]: 'l-store-copy aggregate%as_Encoded(uint64)%1#0 0' +debug: Replaced not_usually_inlined_block@0.ops[17]: 'v-load aggregate%as_Encoded(uint64)%1#0' with 'l-load aggregate%as_Encoded(uint64)%1#0' +debug: Inserted not_usually_inlined_block@0.ops[22]: 'l-store-copy event%0#0 0' +debug: Replaced not_usually_inlined_block@0.ops[24]: 'v-load event%0#0' with 'l-load event%0#0' +debug: Inserted not_usually_inlined_block@0.ops[28]: 'l-store-copy aggregate%val_as_bytes%1#0 0' +debug: Replaced not_usually_inlined_block@0.ops[30]: 'v-load aggregate%val_as_bytes%1#0' with 'l-load aggregate%val_as_bytes%1#0' +debug: Inserted not_usually_inlined_block@0.ops[31]: 'l-store-copy aggregate%as_Encoded(uint64)%2#0 0' +debug: Replaced not_usually_inlined_block@0.ops[33]: 'v-load aggregate%as_Encoded(uint64)%2#0' with 'l-load aggregate%as_Encoded(uint64)%2#0' +debug: Inserted not_usually_inlined_block@0.ops[38]: 'l-store-copy aggregate%head%1#0 0' +debug: Replaced not_usually_inlined_block@0.ops[40]: 'v-load aggregate%head%1#0' with 'l-load aggregate%head%1#0' +debug: Inserted not_usually_inlined_block@0.ops[41]: 'l-store-copy aggregate%as_Encoded(uint64)%3#0 0' +debug: Replaced not_usually_inlined_block@0.ops[43]: 'v-load aggregate%as_Encoded(uint64)%3#0' with 'l-load aggregate%as_Encoded(uint64)%3#0' +debug: Inserted not_usually_inlined_block@0.ops[48]: 'l-store-copy event%1#0 0' +debug: Replaced not_usually_inlined_block@0.ops[50]: 'v-load event%1#0' with 'l-load event%1#0' +debug: Inserted not_usually_inlined_block@0.ops[54]: 'l-store-copy aggregate%val_as_bytes%2#0 0' +debug: Replaced not_usually_inlined_block@0.ops[56]: 'v-load aggregate%val_as_bytes%2#0' with 'l-load aggregate%val_as_bytes%2#0' +debug: Inserted not_usually_inlined_block@0.ops[57]: 'l-store-copy aggregate%as_Encoded(uint64)%4#0 0' +debug: Replaced not_usually_inlined_block@0.ops[59]: 'v-load aggregate%as_Encoded(uint64)%4#0' with 'l-load aggregate%as_Encoded(uint64)%4#0' +debug: Inserted not_usually_inlined_block@0.ops[64]: 'l-store-copy aggregate%head%2#0 0' +debug: Replaced not_usually_inlined_block@0.ops[66]: 'v-load aggregate%head%2#0' with 'l-load aggregate%head%2#0' +debug: Inserted not_usually_inlined_block@0.ops[67]: 'l-store-copy aggregate%as_Encoded(uint64)%5#0 0' +debug: Replaced not_usually_inlined_block@0.ops[69]: 'v-load aggregate%as_Encoded(uint64)%5#0' with 'l-load aggregate%as_Encoded(uint64)%5#0' +debug: Inserted not_usually_inlined_block@0.ops[74]: 'l-store-copy event%2#0 0' +debug: Replaced not_usually_inlined_block@0.ops[76]: 'v-load event%2#0' with 'l-load event%2#0' +debug: Inserted not_usually_inlined_block@0.ops[80]: 'l-store-copy aggregate%val_as_bytes%3#0 0' +debug: Replaced not_usually_inlined_block@0.ops[82]: 'v-load aggregate%val_as_bytes%3#0' with 'l-load aggregate%val_as_bytes%3#0' +debug: Inserted not_usually_inlined_block@0.ops[83]: 'l-store-copy aggregate%as_Encoded(uint64)%6#0 0' +debug: Replaced not_usually_inlined_block@0.ops[85]: 'v-load aggregate%as_Encoded(uint64)%6#0' with 'l-load aggregate%as_Encoded(uint64)%6#0' +debug: Inserted not_usually_inlined_block@0.ops[90]: 'l-store-copy aggregate%head%3#0 0' +debug: Replaced not_usually_inlined_block@0.ops[92]: 'v-load aggregate%head%3#0' with 'l-load aggregate%head%3#0' +debug: Inserted not_usually_inlined_block@0.ops[93]: 'l-store-copy aggregate%as_Encoded(uint64)%7#0 0' +debug: Replaced not_usually_inlined_block@0.ops[95]: 'v-load aggregate%as_Encoded(uint64)%7#0' with 'l-load aggregate%as_Encoded(uint64)%7#0' +debug: Inserted not_usually_inlined_block@0.ops[100]: 'l-store-copy event%3#0 0' +debug: Replaced not_usually_inlined_block@0.ops[102]: 'v-load event%3#0' with 'l-load event%3#0' +debug: Inserted not_usually_inlined_block@0.ops[106]: 'l-store-copy aggregate%val_as_bytes%4#0 0' +debug: Replaced not_usually_inlined_block@0.ops[108]: 'v-load aggregate%val_as_bytes%4#0' with 'l-load aggregate%val_as_bytes%4#0' +debug: Inserted not_usually_inlined_block@0.ops[109]: 'l-store-copy aggregate%as_Encoded(uint64)%8#0 0' +debug: Replaced not_usually_inlined_block@0.ops[111]: 'v-load aggregate%as_Encoded(uint64)%8#0' with 'l-load aggregate%as_Encoded(uint64)%8#0' +debug: Inserted not_usually_inlined_block@0.ops[116]: 'l-store-copy aggregate%head%4#0 0' +debug: Replaced not_usually_inlined_block@0.ops[118]: 'v-load aggregate%head%4#0' with 'l-load aggregate%head%4#0' +debug: Inserted not_usually_inlined_block@0.ops[119]: 'l-store-copy aggregate%as_Encoded(uint64)%9#0 0' +debug: Replaced not_usually_inlined_block@0.ops[121]: 'v-load aggregate%as_Encoded(uint64)%9#0' with 'l-load aggregate%as_Encoded(uint64)%9#0' +debug: Inserted not_usually_inlined_block@0.ops[126]: 'l-store-copy event%4#0 0' +debug: Replaced not_usually_inlined_block@0.ops[128]: 'v-load event%4#0' with 'l-load event%4#0' +debug: Inserted not_usually_inlined_block@0.ops[132]: 'l-store-copy aggregate%val_as_bytes%5#0 0' +debug: Replaced not_usually_inlined_block@0.ops[134]: 'v-load aggregate%val_as_bytes%5#0' with 'l-load aggregate%val_as_bytes%5#0' +debug: Inserted not_usually_inlined_block@0.ops[135]: 'l-store-copy aggregate%as_Encoded(uint64)%10#0 0' +debug: Replaced not_usually_inlined_block@0.ops[137]: 'v-load aggregate%as_Encoded(uint64)%10#0' with 'l-load aggregate%as_Encoded(uint64)%10#0' +debug: Inserted not_usually_inlined_block@0.ops[142]: 'l-store-copy aggregate%head%5#0 0' +debug: Replaced not_usually_inlined_block@0.ops[144]: 'v-load aggregate%head%5#0' with 'l-load aggregate%head%5#0' +debug: Inserted not_usually_inlined_block@0.ops[145]: 'l-store-copy aggregate%as_Encoded(uint64)%11#0 0' +debug: Replaced not_usually_inlined_block@0.ops[147]: 'v-load aggregate%as_Encoded(uint64)%11#0' with 'l-load aggregate%as_Encoded(uint64)%11#0' +debug: Inserted not_usually_inlined_block@0.ops[152]: 'l-store-copy event%5#0 0' +debug: Replaced not_usually_inlined_block@0.ops[154]: 'v-load event%5#0' with 'l-load event%5#0' +debug: Inserted not_usually_inlined_block@0.ops[158]: 'l-store-copy aggregate%val_as_bytes%6#0 0' +debug: Replaced not_usually_inlined_block@0.ops[160]: 'v-load aggregate%val_as_bytes%6#0' with 'l-load aggregate%val_as_bytes%6#0' +debug: Inserted not_usually_inlined_block@0.ops[161]: 'l-store-copy aggregate%as_Encoded(uint64)%12#0 0' +debug: Replaced not_usually_inlined_block@0.ops[163]: 'v-load aggregate%as_Encoded(uint64)%12#0' with 'l-load aggregate%as_Encoded(uint64)%12#0' +debug: Inserted not_usually_inlined_block@0.ops[168]: 'l-store-copy aggregate%head%6#0 0' +debug: Replaced not_usually_inlined_block@0.ops[170]: 'v-load aggregate%head%6#0' with 'l-load aggregate%head%6#0' +debug: Inserted not_usually_inlined_block@0.ops[171]: 'l-store-copy aggregate%as_Encoded(uint64)%13#0 0' +debug: Replaced not_usually_inlined_block@0.ops[173]: 'v-load aggregate%as_Encoded(uint64)%13#0' with 'l-load aggregate%as_Encoded(uint64)%13#0' +debug: Inserted not_usually_inlined_block@0.ops[178]: 'l-store-copy event%6#0 0' +debug: Replaced not_usually_inlined_block@0.ops[180]: 'v-load event%6#0' with 'l-load event%6#0' +debug: Inserted not_usually_inlined_block@0.ops[184]: 'l-store-copy aggregate%val_as_bytes%7#0 0' +debug: Replaced not_usually_inlined_block@0.ops[186]: 'v-load aggregate%val_as_bytes%7#0' with 'l-load aggregate%val_as_bytes%7#0' +debug: Inserted not_usually_inlined_block@0.ops[187]: 'l-store-copy aggregate%as_Encoded(uint64)%14#0 0' +debug: Replaced not_usually_inlined_block@0.ops[189]: 'v-load aggregate%as_Encoded(uint64)%14#0' with 'l-load aggregate%as_Encoded(uint64)%14#0' +debug: Inserted not_usually_inlined_block@0.ops[194]: 'l-store-copy aggregate%head%7#0 0' +debug: Replaced not_usually_inlined_block@0.ops[196]: 'v-load aggregate%head%7#0' with 'l-load aggregate%head%7#0' +debug: Inserted not_usually_inlined_block@0.ops[197]: 'l-store-copy aggregate%as_Encoded(uint64)%15#0 0' +debug: Replaced not_usually_inlined_block@0.ops[199]: 'v-load aggregate%as_Encoded(uint64)%15#0' with 'l-load aggregate%as_Encoded(uint64)%15#0' +debug: Inserted not_usually_inlined_block@0.ops[204]: 'l-store-copy event%7#0 0' +debug: Replaced not_usually_inlined_block@0.ops[206]: 'v-load event%7#0' with 'l-load event%7#0' +debug: Inserted not_usually_inlined_block@0.ops[8]: 'l-store-copy tmp%0#0 0' +debug: Replaced not_usually_inlined_block@0.ops[11]: 'v-load tmp%0#0' with 'l-load tmp%0#0' +debug: Inserted not_usually_inlined_block@0.ops[19]: 'l-store-copy tmp%1#0 0' +debug: Replaced not_usually_inlined_block@0.ops[22]: 'v-load tmp%1#0' with 'l-load tmp%1#0' +debug: Inserted not_usually_inlined_block@0.ops[36]: 'l-store-copy tmp%2#0 0' +debug: Replaced not_usually_inlined_block@0.ops[39]: 'v-load tmp%2#0' with 'l-load tmp%2#0' +debug: Inserted not_usually_inlined_block@0.ops[47]: 'l-store-copy tmp%3#0 0' +debug: Replaced not_usually_inlined_block@0.ops[50]: 'v-load tmp%3#0' with 'l-load tmp%3#0' +debug: Inserted not_usually_inlined_block@0.ops[64]: 'l-store-copy tmp%4#0 0' +debug: Replaced not_usually_inlined_block@0.ops[67]: 'v-load tmp%4#0' with 'l-load tmp%4#0' +debug: Inserted not_usually_inlined_block@0.ops[75]: 'l-store-copy tmp%5#0 0' +debug: Replaced not_usually_inlined_block@0.ops[78]: 'v-load tmp%5#0' with 'l-load tmp%5#0' +debug: Inserted not_usually_inlined_block@0.ops[92]: 'l-store-copy tmp%6#0 0' +debug: Replaced not_usually_inlined_block@0.ops[95]: 'v-load tmp%6#0' with 'l-load tmp%6#0' +debug: Inserted not_usually_inlined_block@0.ops[103]: 'l-store-copy tmp%7#0 0' +debug: Replaced not_usually_inlined_block@0.ops[106]: 'v-load tmp%7#0' with 'l-load tmp%7#0' +debug: Inserted not_usually_inlined_block@0.ops[120]: 'l-store-copy tmp%8#0 0' +debug: Replaced not_usually_inlined_block@0.ops[123]: 'v-load tmp%8#0' with 'l-load tmp%8#0' +debug: Inserted not_usually_inlined_block@0.ops[131]: 'l-store-copy tmp%9#0 0' +debug: Replaced not_usually_inlined_block@0.ops[134]: 'v-load tmp%9#0' with 'l-load tmp%9#0' +debug: Inserted not_usually_inlined_block@0.ops[148]: 'l-store-copy tmp%10#0 0' +debug: Replaced not_usually_inlined_block@0.ops[151]: 'v-load tmp%10#0' with 'l-load tmp%10#0' +debug: Inserted not_usually_inlined_block@0.ops[159]: 'l-store-copy tmp%11#0 0' +debug: Replaced not_usually_inlined_block@0.ops[162]: 'v-load tmp%11#0' with 'l-load tmp%11#0' +debug: Inserted not_usually_inlined_block@0.ops[176]: 'l-store-copy tmp%12#0 0' +debug: Replaced not_usually_inlined_block@0.ops[179]: 'v-load tmp%12#0' with 'l-load tmp%12#0' +debug: Inserted not_usually_inlined_block@0.ops[187]: 'l-store-copy tmp%13#0 0' +debug: Replaced not_usually_inlined_block@0.ops[190]: 'v-load tmp%13#0' with 'l-load tmp%13#0' +debug: Inserted not_usually_inlined_block@0.ops[204]: 'l-store-copy tmp%14#0 0' +debug: Replaced not_usually_inlined_block@0.ops[207]: 'v-load tmp%14#0' with 'l-load tmp%14#0' +debug: Inserted not_usually_inlined_block@0.ops[215]: 'l-store-copy tmp%15#0 0' +debug: Replaced not_usually_inlined_block@0.ops[218]: 'v-load tmp%15#0' with 'l-load tmp%15#0' +debug: Inserted test_cases.structure_methods.contract.TestContract.test_block@0.ops[3]: 'l-store-copy aggregate%head%0#0 0' +debug: Replaced test_cases.structure_methods.contract.TestContract.test_block@0.ops[5]: 'v-load aggregate%head%0#0' with 'l-load aggregate%head%0#0' +debug: Inserted test_cases.structure_methods.contract.TestContract.test_block@0.ops[6]: 'l-store-copy aggregate%as_Encoded(uint64)%0#0 0' +debug: Replaced test_cases.structure_methods.contract.TestContract.test_block@0.ops[8]: 'v-load aggregate%as_Encoded(uint64)%0#0' with 'l-load aggregate%as_Encoded(uint64)%0#0' +debug: Inserted test_cases.structure_methods.contract.TestContract.test_block@0.ops[9]: 'l-store-copy tmp%0#0 0' +debug: Replaced test_cases.structure_methods.contract.TestContract.test_block@0.ops[11]: 'v-load tmp%0#0' with 'l-load tmp%0#0' +debug: Inserted test_cases.structure_methods.contract.TestContract.test_block@0.ops[19]: 'l-store-copy tmp%1#0 0' +debug: Replaced test_cases.structure_methods.contract.TestContract.test_block@0.ops[21]: 'v-load tmp%1#0' with 'l-load tmp%1#0' +debug: Inserted test_cases.structure_methods.contract.TestContract.test_block@0.ops[25]: 'l-store-copy aggregate%val_as_bytes%0#0 0' +debug: Replaced test_cases.structure_methods.contract.TestContract.test_block@0.ops[27]: 'v-load aggregate%val_as_bytes%0#0' with 'l-load aggregate%val_as_bytes%0#0' +debug: Inserted test_cases.structure_methods.contract.TestContract.test_block@0.ops[32]: 'l-store-copy aggregate%head%1#0 0' +debug: Replaced test_cases.structure_methods.contract.TestContract.test_block@0.ops[34]: 'v-load aggregate%head%1#0' with 'l-load aggregate%head%1#0' +debug: Inserted test_cases.structure_methods.contract.TestContract.test_block@0.ops[35]: 'l-store-copy aggregate%as_Encoded(uint64)%2#0 0' +debug: Replaced test_cases.structure_methods.contract.TestContract.test_block@0.ops[37]: 'v-load aggregate%as_Encoded(uint64)%2#0' with 'l-load aggregate%as_Encoded(uint64)%2#0' +debug: Inserted test_cases.structure_methods.contract.TestContract.test_block@0.ops[38]: 'l-store-copy tmp%2#0 0' +debug: Replaced test_cases.structure_methods.contract.TestContract.test_block@0.ops[40]: 'v-load tmp%2#0' with 'l-load tmp%2#0' +debug: Inserted test_cases.structure_methods.contract.TestContract.test_block@0.ops[48]: 'l-store-copy tmp%3#0 0' +debug: Replaced test_cases.structure_methods.contract.TestContract.test_block@0.ops[50]: 'v-load tmp%3#0' with 'l-load tmp%3#0' +debug: Inserted test_cases.structure_methods.contract.TestContract.test_block@0.ops[59]: 'l-store-copy tmp%5#0 0' +debug: Replaced test_cases.structure_methods.contract.TestContract.test_block@0.ops[61]: 'v-load tmp%5#0' with 'l-load tmp%5#0' +debug: Inserted test_cases.structure_methods.contract.TestContract.test_block@0.ops[66]: 'l-store-copy aggregate%head%2#0 0' +debug: Replaced test_cases.structure_methods.contract.TestContract.test_block@0.ops[68]: 'v-load aggregate%head%2#0' with 'l-load aggregate%head%2#0' +debug: Inserted test_cases.structure_methods.contract.TestContract.test_block@0.ops[69]: 'l-store-copy aggregate%as_Encoded(uint64)%3#0 0' +debug: Replaced test_cases.structure_methods.contract.TestContract.test_block@0.ops[71]: 'v-load aggregate%as_Encoded(uint64)%3#0' with 'l-load aggregate%as_Encoded(uint64)%3#0' +debug: Inserted test_cases.structure_methods.contract.TestContract.test_block@0.ops[72]: 'l-store-copy tmp%6#0 0' +debug: Replaced test_cases.structure_methods.contract.TestContract.test_block@0.ops[74]: 'v-load tmp%6#0' with 'l-load tmp%6#0' +debug: Inserted test_cases.structure_methods.contract.TestContract.test_block@0.ops[82]: 'l-store-copy tmp%7#0 0' +debug: Replaced test_cases.structure_methods.contract.TestContract.test_block@0.ops[84]: 'v-load tmp%7#0' with 'l-load tmp%7#0' +debug: Inserted test_cases.structure_methods.contract.TestContract.test_block@0.ops[88]: 'l-store-copy aggregate%val_as_bytes%1#0 0' +debug: Replaced test_cases.structure_methods.contract.TestContract.test_block@0.ops[90]: 'v-load aggregate%val_as_bytes%1#0' with 'l-load aggregate%val_as_bytes%1#0' +debug: Inserted test_cases.structure_methods.contract.TestContract.test_block@0.ops[95]: 'l-store-copy aggregate%head%3#0 0' +debug: Replaced test_cases.structure_methods.contract.TestContract.test_block@0.ops[97]: 'v-load aggregate%head%3#0' with 'l-load aggregate%head%3#0' +debug: Inserted test_cases.structure_methods.contract.TestContract.test_block@0.ops[98]: 'l-store-copy aggregate%as_Encoded(uint64)%5#0 0' +debug: Replaced test_cases.structure_methods.contract.TestContract.test_block@0.ops[100]: 'v-load aggregate%as_Encoded(uint64)%5#0' with 'l-load aggregate%as_Encoded(uint64)%5#0' +debug: Inserted test_cases.structure_methods.contract.TestContract.test_block@0.ops[101]: 'l-store-copy tmp%8#0 0' +debug: Replaced test_cases.structure_methods.contract.TestContract.test_block@0.ops[103]: 'v-load tmp%8#0' with 'l-load tmp%8#0' +debug: Inserted test_cases.structure_methods.contract.TestContract.test_block@0.ops[111]: 'l-store-copy tmp%9#0 0' +debug: Replaced test_cases.structure_methods.contract.TestContract.test_block@0.ops[113]: 'v-load tmp%9#0' with 'l-load tmp%9#0' +debug: Inserted test_cases.structure_methods.contract.TestContract.test_block@0.ops[122]: 'l-store-copy tmp%11#0 0' +debug: Replaced test_cases.structure_methods.contract.TestContract.test_block@0.ops[124]: 'v-load tmp%11#0' with 'l-load tmp%11#0' +debug: Inserted test_cases.structure_methods.contract.TestContract.test_block@0.ops[131]: 'l-store-copy tmp%13#0 0' +debug: Replaced test_cases.structure_methods.contract.TestContract.test_block@0.ops[133]: 'v-load tmp%13#0' with 'l-load tmp%13#0' +debug: Inserted test_cases.structure_methods.contract.TestContract.test_block@0.ops[140]: 'l-store-copy tmp%15#0 0' +debug: Replaced test_cases.structure_methods.contract.TestContract.test_block@0.ops[142]: 'v-load tmp%15#0' with 'l-load tmp%15#0' +debug: Inserted test_cases.structure_methods.contract.TestContract.test_block@0.ops[149]: 'l-store-copy tmp%17#0 0' +debug: Replaced test_cases.structure_methods.contract.TestContract.test_block@0.ops[151]: 'v-load tmp%17#0' with 'l-load tmp%17#0' +debug: Inserted test_cases.structure_methods.contract.TestContract.test_block@0.ops[158]: 'l-store-copy tmp%19#0 0' +debug: Replaced test_cases.structure_methods.contract.TestContract.test_block@0.ops[160]: 'v-load tmp%19#0' with 'l-load tmp%19#0' +debug: Inserted test_cases.structure_methods.contract.TestContract.test_block@0.ops[167]: 'l-store-copy tmp%21#0 0' +debug: Replaced test_cases.structure_methods.contract.TestContract.test_block@0.ops[169]: 'v-load tmp%21#0' with 'l-load tmp%21#0' +debug: Inserted test_cases.structure_methods.contract.TestContract.test_block@0.ops[176]: 'l-store-copy tmp%23#0 0' +debug: Replaced test_cases.structure_methods.contract.TestContract.test_block@0.ops[178]: 'v-load tmp%23#0' with 'l-load tmp%23#0' +debug: Inserted test_cases.structure_methods.contract.TestContract.test_block@0.ops[186]: 'l-store-copy tmp%25#0 0' +debug: Replaced test_cases.structure_methods.contract.TestContract.test_block@0.ops[188]: 'v-load tmp%25#0' with 'l-load tmp%25#0' +debug: Inserted test_cases.structure_methods.contract.TestContract.test_block@0.ops[196]: 'l-store-copy tmp%27#0 0' +debug: Replaced test_cases.structure_methods.contract.TestContract.test_block@0.ops[198]: 'v-load tmp%27#0' with 'l-load tmp%27#0' +debug: Inserted test_cases.structure_methods.contract.TestContract.test_block@0.ops[206]: 'l-store-copy tmp%29#0 0' +debug: Replaced test_cases.structure_methods.contract.TestContract.test_block@0.ops[208]: 'v-load tmp%29#0' with 'l-load tmp%29#0' +debug: Inserted test_cases.structure_methods.contract.TestContract.test_block@0.ops[216]: 'l-store-copy tmp%31#0 0' +debug: Replaced test_cases.structure_methods.contract.TestContract.test_block@0.ops[218]: 'v-load tmp%31#0' with 'l-load tmp%31#0' +debug: Inserted test_cases.structure_methods.contract.TestContract.test_block@0.ops[15]: 'l-store-copy return_value_times%0#0 0' +debug: Replaced test_cases.structure_methods.contract.TestContract.test_block@0.ops[18]: 'v-load return_value_times%0#0' with 'l-load return_value_times%0#0' +debug: Inserted test_cases.structure_methods.contract.TestContract.test_block@0.ops[29]: 'l-store-copy aggregate%as_Encoded(uint64)%1#0 0' +debug: Replaced test_cases.structure_methods.contract.TestContract.test_block@0.ops[32]: 'v-load aggregate%as_Encoded(uint64)%1#0' with 'l-load aggregate%as_Encoded(uint64)%1#0' +debug: Inserted test_cases.structure_methods.contract.TestContract.test_block@0.ops[46]: 'l-store-copy return_value_times%2#0 0' +debug: Replaced test_cases.structure_methods.contract.TestContract.test_block@0.ops[49]: 'v-load return_value_times%2#0' with 'l-load return_value_times%2#0' +debug: Inserted test_cases.structure_methods.contract.TestContract.test_block@0.ops[58]: 'l-store-copy tmp%4#0 0' +debug: Replaced test_cases.structure_methods.contract.TestContract.test_block@0.ops[61]: 'v-load tmp%4#0' with 'l-load tmp%4#0' +debug: Inserted test_cases.structure_methods.contract.TestContract.test_block@0.ops[82]: 'l-store-copy return_value_times%4#0 0' +debug: Replaced test_cases.structure_methods.contract.TestContract.test_block@0.ops[85]: 'v-load return_value_times%4#0' with 'l-load return_value_times%4#0' +debug: Inserted test_cases.structure_methods.contract.TestContract.test_block@0.ops[96]: 'l-store-copy aggregate%as_Encoded(uint64)%4#0 0' +debug: Replaced test_cases.structure_methods.contract.TestContract.test_block@0.ops[99]: 'v-load aggregate%as_Encoded(uint64)%4#0' with 'l-load aggregate%as_Encoded(uint64)%4#0' +debug: Inserted test_cases.structure_methods.contract.TestContract.test_block@0.ops[113]: 'l-store-copy return_value_times%6#0 0' +debug: Replaced test_cases.structure_methods.contract.TestContract.test_block@0.ops[116]: 'v-load return_value_times%6#0' with 'l-load return_value_times%6#0' +debug: Inserted test_cases.structure_methods.contract.TestContract.test_block@0.ops[125]: 'l-store-copy tmp%10#0 0' +debug: Replaced test_cases.structure_methods.contract.TestContract.test_block@0.ops[128]: 'v-load tmp%10#0' with 'l-load tmp%10#0' +debug: Inserted test_cases.structure_methods.contract.TestContract.test_block@0.ops[135]: 'l-store-copy tmp%12#0 0' +debug: Replaced test_cases.structure_methods.contract.TestContract.test_block@0.ops[138]: 'v-load tmp%12#0' with 'l-load tmp%12#0' +debug: Inserted test_cases.structure_methods.contract.TestContract.test_block@0.ops[145]: 'l-store-copy tmp%14#0 0' +debug: Replaced test_cases.structure_methods.contract.TestContract.test_block@0.ops[148]: 'v-load tmp%14#0' with 'l-load tmp%14#0' +debug: Inserted test_cases.structure_methods.contract.TestContract.test_block@0.ops[155]: 'l-store-copy tmp%16#0 0' +debug: Replaced test_cases.structure_methods.contract.TestContract.test_block@0.ops[158]: 'v-load tmp%16#0' with 'l-load tmp%16#0' +debug: Inserted test_cases.structure_methods.contract.TestContract.test_block@0.ops[165]: 'l-store-copy tmp%18#0 0' +debug: Replaced test_cases.structure_methods.contract.TestContract.test_block@0.ops[168]: 'v-load tmp%18#0' with 'l-load tmp%18#0' +debug: Inserted test_cases.structure_methods.contract.TestContract.test_block@0.ops[175]: 'l-store-copy tmp%20#0 0' +debug: Replaced test_cases.structure_methods.contract.TestContract.test_block@0.ops[178]: 'v-load tmp%20#0' with 'l-load tmp%20#0' +debug: Inserted test_cases.structure_methods.contract.TestContract.test_block@0.ops[185]: 'l-store-copy tmp%22#0 0' +debug: Replaced test_cases.structure_methods.contract.TestContract.test_block@0.ops[188]: 'v-load tmp%22#0' with 'l-load tmp%22#0' +debug: Inserted test_cases.structure_methods.contract.TestContract.test_block@0.ops[196]: 'l-store-copy tmp%24#0 0' +debug: Replaced test_cases.structure_methods.contract.TestContract.test_block@0.ops[199]: 'v-load tmp%24#0' with 'l-load tmp%24#0' +debug: Inserted test_cases.structure_methods.contract.TestContract.test_block@0.ops[207]: 'l-store-copy tmp%26#0 0' +debug: Replaced test_cases.structure_methods.contract.TestContract.test_block@0.ops[210]: 'v-load tmp%26#0' with 'l-load tmp%26#0' +debug: Inserted test_cases.structure_methods.contract.TestContract.test_block@0.ops[218]: 'l-store-copy tmp%28#0 0' +debug: Replaced test_cases.structure_methods.contract.TestContract.test_block@0.ops[221]: 'v-load tmp%28#0' with 'l-load tmp%28#0' +debug: Inserted test_cases.structure_methods.contract.TestContract.test_block@0.ops[229]: 'l-store-copy tmp%30#0 0' +debug: Replaced test_cases.structure_methods.contract.TestContract.test_block@0.ops[232]: 'v-load tmp%30#0' with 'l-load tmp%30#0' +debug: Inserted test_cases.structure_methods.contract.TestContract.test_block@1.ops[2]: 'l-store-copy aggregate%val_as_bytes%2#0 0' +debug: Replaced test_cases.structure_methods.contract.TestContract.test_block@1.ops[4]: 'v-load aggregate%val_as_bytes%2#0' with 'l-load aggregate%val_as_bytes%2#0' +debug: Inserted test_cases.structure_methods.contract.TestContract.test_block@1.ops[5]: 'l-store-copy aggregate%as_Encoded(uint64)%6#0 0' +debug: Replaced test_cases.structure_methods.contract.TestContract.test_block@1.ops[7]: 'v-load aggregate%as_Encoded(uint64)%6#0' with 'l-load aggregate%as_Encoded(uint64)%6#0' +debug: Inserted test_cases.structure_methods.contract.TestContract.test_block@1.ops[12]: 'l-store-copy aggregate%head%4#0 0' +debug: Replaced test_cases.structure_methods.contract.TestContract.test_block@1.ops[14]: 'v-load aggregate%head%4#0' with 'l-load aggregate%head%4#0' +debug: Inserted test_cases.structure_methods.contract.TestContract.test_block@1.ops[15]: 'l-store-copy aggregate%as_Encoded(uint64)%7#0 0' +debug: Replaced test_cases.structure_methods.contract.TestContract.test_block@1.ops[17]: 'v-load aggregate%as_Encoded(uint64)%7#0' with 'l-load aggregate%as_Encoded(uint64)%7#0' +debug: Inserted test_cases.structure_methods.contract.TestContract.test_block@1.ops[22]: 'l-store-copy event%0#0 0' +debug: Replaced test_cases.structure_methods.contract.TestContract.test_block@1.ops[24]: 'v-load event%0#0' with 'l-load event%0#0' +debug: Inserted test_cases.structure_methods.contract.TestContract.test_block@1.ops[28]: 'l-store-copy aggregate%val_as_bytes%3#0 0' +debug: Replaced test_cases.structure_methods.contract.TestContract.test_block@1.ops[30]: 'v-load aggregate%val_as_bytes%3#0' with 'l-load aggregate%val_as_bytes%3#0' +debug: Inserted test_cases.structure_methods.contract.TestContract.test_block@1.ops[31]: 'l-store-copy aggregate%as_Encoded(uint64)%8#0 0' +debug: Replaced test_cases.structure_methods.contract.TestContract.test_block@1.ops[33]: 'v-load aggregate%as_Encoded(uint64)%8#0' with 'l-load aggregate%as_Encoded(uint64)%8#0' +debug: Inserted test_cases.structure_methods.contract.TestContract.test_block@1.ops[38]: 'l-store-copy aggregate%head%5#0 0' +debug: Replaced test_cases.structure_methods.contract.TestContract.test_block@1.ops[40]: 'v-load aggregate%head%5#0' with 'l-load aggregate%head%5#0' +debug: Inserted test_cases.structure_methods.contract.TestContract.test_block@1.ops[41]: 'l-store-copy aggregate%as_Encoded(uint64)%9#0 0' +debug: Replaced test_cases.structure_methods.contract.TestContract.test_block@1.ops[43]: 'v-load aggregate%as_Encoded(uint64)%9#0' with 'l-load aggregate%as_Encoded(uint64)%9#0' +debug: Inserted test_cases.structure_methods.contract.TestContract.test_block@1.ops[48]: 'l-store-copy event%1#0 0' +debug: Replaced test_cases.structure_methods.contract.TestContract.test_block@1.ops[50]: 'v-load event%1#0' with 'l-load event%1#0' +debug: Inserted test_cases.structure_methods.contract.TestContract.test_block@1.ops[54]: 'l-store-copy aggregate%val_as_bytes%4#0 0' +debug: Replaced test_cases.structure_methods.contract.TestContract.test_block@1.ops[56]: 'v-load aggregate%val_as_bytes%4#0' with 'l-load aggregate%val_as_bytes%4#0' +debug: Inserted test_cases.structure_methods.contract.TestContract.test_block@1.ops[57]: 'l-store-copy aggregate%as_Encoded(uint64)%10#0 0' +debug: Replaced test_cases.structure_methods.contract.TestContract.test_block@1.ops[59]: 'v-load aggregate%as_Encoded(uint64)%10#0' with 'l-load aggregate%as_Encoded(uint64)%10#0' +debug: Inserted test_cases.structure_methods.contract.TestContract.test_block@1.ops[64]: 'l-store-copy aggregate%head%6#0 0' +debug: Replaced test_cases.structure_methods.contract.TestContract.test_block@1.ops[66]: 'v-load aggregate%head%6#0' with 'l-load aggregate%head%6#0' +debug: Inserted test_cases.structure_methods.contract.TestContract.test_block@1.ops[67]: 'l-store-copy aggregate%as_Encoded(uint64)%11#0 0' +debug: Replaced test_cases.structure_methods.contract.TestContract.test_block@1.ops[69]: 'v-load aggregate%as_Encoded(uint64)%11#0' with 'l-load aggregate%as_Encoded(uint64)%11#0' +debug: Inserted test_cases.structure_methods.contract.TestContract.test_block@1.ops[74]: 'l-store-copy event%2#0 0' +debug: Replaced test_cases.structure_methods.contract.TestContract.test_block@1.ops[76]: 'v-load event%2#0' with 'l-load event%2#0' +debug: Inserted test_cases.structure_methods.contract.TestContract.test_block@1.ops[80]: 'l-store-copy aggregate%val_as_bytes%5#0 0' +debug: Replaced test_cases.structure_methods.contract.TestContract.test_block@1.ops[82]: 'v-load aggregate%val_as_bytes%5#0' with 'l-load aggregate%val_as_bytes%5#0' +debug: Inserted test_cases.structure_methods.contract.TestContract.test_block@1.ops[83]: 'l-store-copy aggregate%as_Encoded(uint64)%12#0 0' +debug: Replaced test_cases.structure_methods.contract.TestContract.test_block@1.ops[85]: 'v-load aggregate%as_Encoded(uint64)%12#0' with 'l-load aggregate%as_Encoded(uint64)%12#0' +debug: Inserted test_cases.structure_methods.contract.TestContract.test_block@1.ops[90]: 'l-store-copy aggregate%head%7#0 0' +debug: Replaced test_cases.structure_methods.contract.TestContract.test_block@1.ops[92]: 'v-load aggregate%head%7#0' with 'l-load aggregate%head%7#0' +debug: Inserted test_cases.structure_methods.contract.TestContract.test_block@1.ops[93]: 'l-store-copy aggregate%as_Encoded(uint64)%13#0 0' +debug: Replaced test_cases.structure_methods.contract.TestContract.test_block@1.ops[95]: 'v-load aggregate%as_Encoded(uint64)%13#0' with 'l-load aggregate%as_Encoded(uint64)%13#0' +debug: Inserted test_cases.structure_methods.contract.TestContract.test_block@1.ops[100]: 'l-store-copy event%3#0 0' +debug: Replaced test_cases.structure_methods.contract.TestContract.test_block@1.ops[102]: 'v-load event%3#0' with 'l-load event%3#0' +debug: Inserted test_cases.structure_methods.contract.TestContract.test_block@1.ops[106]: 'l-store-copy aggregate%val_as_bytes%6#0 0' +debug: Replaced test_cases.structure_methods.contract.TestContract.test_block@1.ops[108]: 'v-load aggregate%val_as_bytes%6#0' with 'l-load aggregate%val_as_bytes%6#0' +debug: Inserted test_cases.structure_methods.contract.TestContract.test_block@1.ops[109]: 'l-store-copy aggregate%as_Encoded(uint64)%14#0 0' +debug: Replaced test_cases.structure_methods.contract.TestContract.test_block@1.ops[111]: 'v-load aggregate%as_Encoded(uint64)%14#0' with 'l-load aggregate%as_Encoded(uint64)%14#0' +debug: Inserted test_cases.structure_methods.contract.TestContract.test_block@1.ops[116]: 'l-store-copy aggregate%head%8#0 0' +debug: Replaced test_cases.structure_methods.contract.TestContract.test_block@1.ops[118]: 'v-load aggregate%head%8#0' with 'l-load aggregate%head%8#0' +debug: Inserted test_cases.structure_methods.contract.TestContract.test_block@1.ops[119]: 'l-store-copy aggregate%as_Encoded(uint64)%15#0 0' +debug: Replaced test_cases.structure_methods.contract.TestContract.test_block@1.ops[121]: 'v-load aggregate%as_Encoded(uint64)%15#0' with 'l-load aggregate%as_Encoded(uint64)%15#0' +debug: Inserted test_cases.structure_methods.contract.TestContract.test_block@1.ops[126]: 'l-store-copy event%4#0 0' +debug: Replaced test_cases.structure_methods.contract.TestContract.test_block@1.ops[128]: 'v-load event%4#0' with 'l-load event%4#0' +debug: Inserted test_cases.structure_methods.contract.TestContract.test_block@1.ops[132]: 'l-store-copy aggregate%val_as_bytes%7#0 0' +debug: Replaced test_cases.structure_methods.contract.TestContract.test_block@1.ops[134]: 'v-load aggregate%val_as_bytes%7#0' with 'l-load aggregate%val_as_bytes%7#0' +debug: Inserted test_cases.structure_methods.contract.TestContract.test_block@1.ops[135]: 'l-store-copy aggregate%as_Encoded(uint64)%16#0 0' +debug: Replaced test_cases.structure_methods.contract.TestContract.test_block@1.ops[137]: 'v-load aggregate%as_Encoded(uint64)%16#0' with 'l-load aggregate%as_Encoded(uint64)%16#0' +debug: Inserted test_cases.structure_methods.contract.TestContract.test_block@1.ops[142]: 'l-store-copy aggregate%head%9#0 0' +debug: Replaced test_cases.structure_methods.contract.TestContract.test_block@1.ops[144]: 'v-load aggregate%head%9#0' with 'l-load aggregate%head%9#0' +debug: Inserted test_cases.structure_methods.contract.TestContract.test_block@1.ops[145]: 'l-store-copy aggregate%as_Encoded(uint64)%17#0 0' +debug: Replaced test_cases.structure_methods.contract.TestContract.test_block@1.ops[147]: 'v-load aggregate%as_Encoded(uint64)%17#0' with 'l-load aggregate%as_Encoded(uint64)%17#0' +debug: Inserted test_cases.structure_methods.contract.TestContract.test_block@1.ops[152]: 'l-store-copy event%5#0 0' +debug: Replaced test_cases.structure_methods.contract.TestContract.test_block@1.ops[154]: 'v-load event%5#0' with 'l-load event%5#0' +debug: Inserted test_cases.structure_methods.contract.TestContract.test_block@1.ops[158]: 'l-store-copy aggregate%val_as_bytes%8#0 0' +debug: Replaced test_cases.structure_methods.contract.TestContract.test_block@1.ops[160]: 'v-load aggregate%val_as_bytes%8#0' with 'l-load aggregate%val_as_bytes%8#0' +debug: Inserted test_cases.structure_methods.contract.TestContract.test_block@1.ops[161]: 'l-store-copy aggregate%as_Encoded(uint64)%18#0 0' +debug: Replaced test_cases.structure_methods.contract.TestContract.test_block@1.ops[163]: 'v-load aggregate%as_Encoded(uint64)%18#0' with 'l-load aggregate%as_Encoded(uint64)%18#0' +debug: Inserted test_cases.structure_methods.contract.TestContract.test_block@1.ops[168]: 'l-store-copy aggregate%head%10#0 0' +debug: Replaced test_cases.structure_methods.contract.TestContract.test_block@1.ops[170]: 'v-load aggregate%head%10#0' with 'l-load aggregate%head%10#0' +debug: Inserted test_cases.structure_methods.contract.TestContract.test_block@1.ops[171]: 'l-store-copy aggregate%as_Encoded(uint64)%19#0 0' +debug: Replaced test_cases.structure_methods.contract.TestContract.test_block@1.ops[173]: 'v-load aggregate%as_Encoded(uint64)%19#0' with 'l-load aggregate%as_Encoded(uint64)%19#0' +debug: Inserted test_cases.structure_methods.contract.TestContract.test_block@1.ops[178]: 'l-store-copy event%6#0 0' +debug: Replaced test_cases.structure_methods.contract.TestContract.test_block@1.ops[180]: 'v-load event%6#0' with 'l-load event%6#0' +debug: Inserted test_cases.structure_methods.contract.TestContract.test_block@1.ops[184]: 'l-store-copy aggregate%val_as_bytes%9#0 0' +debug: Replaced test_cases.structure_methods.contract.TestContract.test_block@1.ops[186]: 'v-load aggregate%val_as_bytes%9#0' with 'l-load aggregate%val_as_bytes%9#0' +debug: Inserted test_cases.structure_methods.contract.TestContract.test_block@1.ops[187]: 'l-store-copy aggregate%as_Encoded(uint64)%20#0 0' +debug: Replaced test_cases.structure_methods.contract.TestContract.test_block@1.ops[189]: 'v-load aggregate%as_Encoded(uint64)%20#0' with 'l-load aggregate%as_Encoded(uint64)%20#0' +debug: Inserted test_cases.structure_methods.contract.TestContract.test_block@1.ops[194]: 'l-store-copy aggregate%head%11#0 0' +debug: Replaced test_cases.structure_methods.contract.TestContract.test_block@1.ops[196]: 'v-load aggregate%head%11#0' with 'l-load aggregate%head%11#0' +debug: Inserted test_cases.structure_methods.contract.TestContract.test_block@1.ops[197]: 'l-store-copy aggregate%as_Encoded(uint64)%21#0 0' +debug: Replaced test_cases.structure_methods.contract.TestContract.test_block@1.ops[199]: 'v-load aggregate%as_Encoded(uint64)%21#0' with 'l-load aggregate%as_Encoded(uint64)%21#0' +debug: Inserted test_cases.structure_methods.contract.TestContract.test_block@1.ops[204]: 'l-store-copy event%7#0 0' +debug: Replaced test_cases.structure_methods.contract.TestContract.test_block@1.ops[206]: 'v-load event%7#0' with 'l-load event%7#0' +debug: Inserted test_cases.structure_methods.contract.TestContract.test_block@1.ops[8]: 'l-store-copy tmp%0#0 0' +debug: Replaced test_cases.structure_methods.contract.TestContract.test_block@1.ops[11]: 'v-load tmp%0#0' with 'l-load tmp%0#0' +debug: Inserted test_cases.structure_methods.contract.TestContract.test_block@1.ops[19]: 'l-store-copy tmp%1#1 0' +debug: Replaced test_cases.structure_methods.contract.TestContract.test_block@1.ops[22]: 'v-load tmp%1#1' with 'l-load tmp%1#1' +debug: Inserted test_cases.structure_methods.contract.TestContract.test_block@1.ops[36]: 'l-store-copy tmp%2#0 0' +debug: Replaced test_cases.structure_methods.contract.TestContract.test_block@1.ops[39]: 'v-load tmp%2#0' with 'l-load tmp%2#0' +debug: Inserted test_cases.structure_methods.contract.TestContract.test_block@1.ops[47]: 'l-store-copy tmp%3#1 0' +debug: Replaced test_cases.structure_methods.contract.TestContract.test_block@1.ops[50]: 'v-load tmp%3#1' with 'l-load tmp%3#1' +debug: Inserted test_cases.structure_methods.contract.TestContract.test_block@1.ops[64]: 'l-store-copy tmp%4#1 0' +debug: Replaced test_cases.structure_methods.contract.TestContract.test_block@1.ops[67]: 'v-load tmp%4#1' with 'l-load tmp%4#1' +debug: Inserted test_cases.structure_methods.contract.TestContract.test_block@1.ops[75]: 'l-store-copy tmp%5#1 0' +debug: Replaced test_cases.structure_methods.contract.TestContract.test_block@1.ops[78]: 'v-load tmp%5#1' with 'l-load tmp%5#1' +debug: Inserted test_cases.structure_methods.contract.TestContract.test_block@1.ops[92]: 'l-store-copy tmp%6#0 0' +debug: Replaced test_cases.structure_methods.contract.TestContract.test_block@1.ops[95]: 'v-load tmp%6#0' with 'l-load tmp%6#0' +debug: Inserted test_cases.structure_methods.contract.TestContract.test_block@1.ops[103]: 'l-store-copy tmp%7#1 0' +debug: Replaced test_cases.structure_methods.contract.TestContract.test_block@1.ops[106]: 'v-load tmp%7#1' with 'l-load tmp%7#1' +debug: Inserted test_cases.structure_methods.contract.TestContract.test_block@1.ops[120]: 'l-store-copy tmp%8#0 0' +debug: Replaced test_cases.structure_methods.contract.TestContract.test_block@1.ops[123]: 'v-load tmp%8#0' with 'l-load tmp%8#0' +debug: Inserted test_cases.structure_methods.contract.TestContract.test_block@1.ops[131]: 'l-store-copy tmp%9#1 0' +debug: Replaced test_cases.structure_methods.contract.TestContract.test_block@1.ops[134]: 'v-load tmp%9#1' with 'l-load tmp%9#1' +debug: Inserted test_cases.structure_methods.contract.TestContract.test_block@1.ops[148]: 'l-store-copy tmp%10#1 0' +debug: Replaced test_cases.structure_methods.contract.TestContract.test_block@1.ops[151]: 'v-load tmp%10#1' with 'l-load tmp%10#1' +debug: Inserted test_cases.structure_methods.contract.TestContract.test_block@1.ops[159]: 'l-store-copy tmp%11#1 0' +debug: Replaced test_cases.structure_methods.contract.TestContract.test_block@1.ops[162]: 'v-load tmp%11#1' with 'l-load tmp%11#1' +debug: Inserted test_cases.structure_methods.contract.TestContract.test_block@1.ops[176]: 'l-store-copy tmp%12#1 0' +debug: Replaced test_cases.structure_methods.contract.TestContract.test_block@1.ops[179]: 'v-load tmp%12#1' with 'l-load tmp%12#1' +debug: Inserted test_cases.structure_methods.contract.TestContract.test_block@1.ops[187]: 'l-store-copy tmp%13#1 0' +debug: Replaced test_cases.structure_methods.contract.TestContract.test_block@1.ops[190]: 'v-load tmp%13#1' with 'l-load tmp%13#1' +debug: Inserted test_cases.structure_methods.contract.TestContract.test_block@1.ops[204]: 'l-store-copy tmp%14#1 0' +debug: Replaced test_cases.structure_methods.contract.TestContract.test_block@1.ops[207]: 'v-load tmp%14#1' with 'l-load tmp%14#1' +debug: Inserted test_cases.structure_methods.contract.TestContract.test_block@1.ops[215]: 'l-store-copy tmp%15#1 0' +debug: Replaced test_cases.structure_methods.contract.TestContract.test_block@1.ops[218]: 'v-load tmp%15#1' with 'l-load tmp%15#1' +debug: Inserted test_cases.structure_methods.contract.TestContract.test_block@3.ops[2]: 'l-store-copy aggregate%val_as_bytes%10#0 0' +debug: Replaced test_cases.structure_methods.contract.TestContract.test_block@3.ops[4]: 'v-load aggregate%val_as_bytes%10#0' with 'l-load aggregate%val_as_bytes%10#0' +debug: Inserted test_cases.structure_methods.contract.TestContract.test_block@3.ops[5]: 'l-store-copy aggregate%as_Encoded(uint64)%22#0 0' +debug: Replaced test_cases.structure_methods.contract.TestContract.test_block@3.ops[7]: 'v-load aggregate%as_Encoded(uint64)%22#0' with 'l-load aggregate%as_Encoded(uint64)%22#0' +debug: Inserted test_cases.structure_methods.contract.TestContract.test_block@3.ops[12]: 'l-store-copy aggregate%head%12#0 0' +debug: Replaced test_cases.structure_methods.contract.TestContract.test_block@3.ops[14]: 'v-load aggregate%head%12#0' with 'l-load aggregate%head%12#0' +debug: Inserted test_cases.structure_methods.contract.TestContract.test_block@3.ops[15]: 'l-store-copy aggregate%as_Encoded(uint64)%23#0 0' +debug: Replaced test_cases.structure_methods.contract.TestContract.test_block@3.ops[17]: 'v-load aggregate%as_Encoded(uint64)%23#0' with 'l-load aggregate%as_Encoded(uint64)%23#0' +debug: Inserted test_cases.structure_methods.contract.TestContract.test_block@3.ops[22]: 'l-store-copy event%0#0 0' +debug: Replaced test_cases.structure_methods.contract.TestContract.test_block@3.ops[24]: 'v-load event%0#0' with 'l-load event%0#0' +debug: Inserted test_cases.structure_methods.contract.TestContract.test_block@3.ops[28]: 'l-store-copy aggregate%val_as_bytes%11#0 0' +debug: Replaced test_cases.structure_methods.contract.TestContract.test_block@3.ops[30]: 'v-load aggregate%val_as_bytes%11#0' with 'l-load aggregate%val_as_bytes%11#0' +debug: Inserted test_cases.structure_methods.contract.TestContract.test_block@3.ops[31]: 'l-store-copy aggregate%as_Encoded(uint64)%24#0 0' +debug: Replaced test_cases.structure_methods.contract.TestContract.test_block@3.ops[33]: 'v-load aggregate%as_Encoded(uint64)%24#0' with 'l-load aggregate%as_Encoded(uint64)%24#0' +debug: Inserted test_cases.structure_methods.contract.TestContract.test_block@3.ops[38]: 'l-store-copy aggregate%head%13#0 0' +debug: Replaced test_cases.structure_methods.contract.TestContract.test_block@3.ops[40]: 'v-load aggregate%head%13#0' with 'l-load aggregate%head%13#0' +debug: Inserted test_cases.structure_methods.contract.TestContract.test_block@3.ops[41]: 'l-store-copy aggregate%as_Encoded(uint64)%25#0 0' +debug: Replaced test_cases.structure_methods.contract.TestContract.test_block@3.ops[43]: 'v-load aggregate%as_Encoded(uint64)%25#0' with 'l-load aggregate%as_Encoded(uint64)%25#0' +debug: Inserted test_cases.structure_methods.contract.TestContract.test_block@3.ops[48]: 'l-store-copy event%1#0 0' +debug: Replaced test_cases.structure_methods.contract.TestContract.test_block@3.ops[50]: 'v-load event%1#0' with 'l-load event%1#0' +debug: Inserted test_cases.structure_methods.contract.TestContract.test_block@3.ops[54]: 'l-store-copy aggregate%val_as_bytes%12#0 0' +debug: Replaced test_cases.structure_methods.contract.TestContract.test_block@3.ops[56]: 'v-load aggregate%val_as_bytes%12#0' with 'l-load aggregate%val_as_bytes%12#0' +debug: Inserted test_cases.structure_methods.contract.TestContract.test_block@3.ops[57]: 'l-store-copy aggregate%as_Encoded(uint64)%26#0 0' +debug: Replaced test_cases.structure_methods.contract.TestContract.test_block@3.ops[59]: 'v-load aggregate%as_Encoded(uint64)%26#0' with 'l-load aggregate%as_Encoded(uint64)%26#0' +debug: Inserted test_cases.structure_methods.contract.TestContract.test_block@3.ops[64]: 'l-store-copy aggregate%head%14#0 0' +debug: Replaced test_cases.structure_methods.contract.TestContract.test_block@3.ops[66]: 'v-load aggregate%head%14#0' with 'l-load aggregate%head%14#0' +debug: Inserted test_cases.structure_methods.contract.TestContract.test_block@3.ops[67]: 'l-store-copy aggregate%as_Encoded(uint64)%27#0 0' +debug: Replaced test_cases.structure_methods.contract.TestContract.test_block@3.ops[69]: 'v-load aggregate%as_Encoded(uint64)%27#0' with 'l-load aggregate%as_Encoded(uint64)%27#0' +debug: Inserted test_cases.structure_methods.contract.TestContract.test_block@3.ops[74]: 'l-store-copy event%2#0 0' +debug: Replaced test_cases.structure_methods.contract.TestContract.test_block@3.ops[76]: 'v-load event%2#0' with 'l-load event%2#0' +debug: Inserted test_cases.structure_methods.contract.TestContract.test_block@3.ops[80]: 'l-store-copy aggregate%val_as_bytes%13#0 0' +debug: Replaced test_cases.structure_methods.contract.TestContract.test_block@3.ops[82]: 'v-load aggregate%val_as_bytes%13#0' with 'l-load aggregate%val_as_bytes%13#0' +debug: Inserted test_cases.structure_methods.contract.TestContract.test_block@3.ops[83]: 'l-store-copy aggregate%as_Encoded(uint64)%28#0 0' +debug: Replaced test_cases.structure_methods.contract.TestContract.test_block@3.ops[85]: 'v-load aggregate%as_Encoded(uint64)%28#0' with 'l-load aggregate%as_Encoded(uint64)%28#0' +debug: Inserted test_cases.structure_methods.contract.TestContract.test_block@3.ops[90]: 'l-store-copy aggregate%head%15#0 0' +debug: Replaced test_cases.structure_methods.contract.TestContract.test_block@3.ops[92]: 'v-load aggregate%head%15#0' with 'l-load aggregate%head%15#0' +debug: Inserted test_cases.structure_methods.contract.TestContract.test_block@3.ops[93]: 'l-store-copy aggregate%as_Encoded(uint64)%29#0 0' +debug: Replaced test_cases.structure_methods.contract.TestContract.test_block@3.ops[95]: 'v-load aggregate%as_Encoded(uint64)%29#0' with 'l-load aggregate%as_Encoded(uint64)%29#0' +debug: Inserted test_cases.structure_methods.contract.TestContract.test_block@3.ops[100]: 'l-store-copy event%3#0 0' +debug: Replaced test_cases.structure_methods.contract.TestContract.test_block@3.ops[102]: 'v-load event%3#0' with 'l-load event%3#0' +debug: Inserted test_cases.structure_methods.contract.TestContract.test_block@3.ops[106]: 'l-store-copy aggregate%val_as_bytes%14#0 0' +debug: Replaced test_cases.structure_methods.contract.TestContract.test_block@3.ops[108]: 'v-load aggregate%val_as_bytes%14#0' with 'l-load aggregate%val_as_bytes%14#0' +debug: Inserted test_cases.structure_methods.contract.TestContract.test_block@3.ops[109]: 'l-store-copy aggregate%as_Encoded(uint64)%30#0 0' +debug: Replaced test_cases.structure_methods.contract.TestContract.test_block@3.ops[111]: 'v-load aggregate%as_Encoded(uint64)%30#0' with 'l-load aggregate%as_Encoded(uint64)%30#0' +debug: Inserted test_cases.structure_methods.contract.TestContract.test_block@3.ops[116]: 'l-store-copy aggregate%head%16#0 0' +debug: Replaced test_cases.structure_methods.contract.TestContract.test_block@3.ops[118]: 'v-load aggregate%head%16#0' with 'l-load aggregate%head%16#0' +debug: Inserted test_cases.structure_methods.contract.TestContract.test_block@3.ops[119]: 'l-store-copy aggregate%as_Encoded(uint64)%31#0 0' +debug: Replaced test_cases.structure_methods.contract.TestContract.test_block@3.ops[121]: 'v-load aggregate%as_Encoded(uint64)%31#0' with 'l-load aggregate%as_Encoded(uint64)%31#0' +debug: Inserted test_cases.structure_methods.contract.TestContract.test_block@3.ops[126]: 'l-store-copy event%4#0 0' +debug: Replaced test_cases.structure_methods.contract.TestContract.test_block@3.ops[128]: 'v-load event%4#0' with 'l-load event%4#0' +debug: Inserted test_cases.structure_methods.contract.TestContract.test_block@3.ops[132]: 'l-store-copy aggregate%val_as_bytes%15#0 0' +debug: Replaced test_cases.structure_methods.contract.TestContract.test_block@3.ops[134]: 'v-load aggregate%val_as_bytes%15#0' with 'l-load aggregate%val_as_bytes%15#0' +debug: Inserted test_cases.structure_methods.contract.TestContract.test_block@3.ops[135]: 'l-store-copy aggregate%as_Encoded(uint64)%32#0 0' +debug: Replaced test_cases.structure_methods.contract.TestContract.test_block@3.ops[137]: 'v-load aggregate%as_Encoded(uint64)%32#0' with 'l-load aggregate%as_Encoded(uint64)%32#0' +debug: Inserted test_cases.structure_methods.contract.TestContract.test_block@3.ops[142]: 'l-store-copy aggregate%head%17#0 0' +debug: Replaced test_cases.structure_methods.contract.TestContract.test_block@3.ops[144]: 'v-load aggregate%head%17#0' with 'l-load aggregate%head%17#0' +debug: Inserted test_cases.structure_methods.contract.TestContract.test_block@3.ops[145]: 'l-store-copy aggregate%as_Encoded(uint64)%33#0 0' +debug: Replaced test_cases.structure_methods.contract.TestContract.test_block@3.ops[147]: 'v-load aggregate%as_Encoded(uint64)%33#0' with 'l-load aggregate%as_Encoded(uint64)%33#0' +debug: Inserted test_cases.structure_methods.contract.TestContract.test_block@3.ops[152]: 'l-store-copy event%5#0 0' +debug: Replaced test_cases.structure_methods.contract.TestContract.test_block@3.ops[154]: 'v-load event%5#0' with 'l-load event%5#0' +debug: Inserted test_cases.structure_methods.contract.TestContract.test_block@3.ops[158]: 'l-store-copy aggregate%val_as_bytes%16#0 0' +debug: Replaced test_cases.structure_methods.contract.TestContract.test_block@3.ops[160]: 'v-load aggregate%val_as_bytes%16#0' with 'l-load aggregate%val_as_bytes%16#0' +debug: Inserted test_cases.structure_methods.contract.TestContract.test_block@3.ops[161]: 'l-store-copy aggregate%as_Encoded(uint64)%34#0 0' +debug: Replaced test_cases.structure_methods.contract.TestContract.test_block@3.ops[163]: 'v-load aggregate%as_Encoded(uint64)%34#0' with 'l-load aggregate%as_Encoded(uint64)%34#0' +debug: Inserted test_cases.structure_methods.contract.TestContract.test_block@3.ops[168]: 'l-store-copy aggregate%head%18#0 0' +debug: Replaced test_cases.structure_methods.contract.TestContract.test_block@3.ops[170]: 'v-load aggregate%head%18#0' with 'l-load aggregate%head%18#0' +debug: Inserted test_cases.structure_methods.contract.TestContract.test_block@3.ops[171]: 'l-store-copy aggregate%as_Encoded(uint64)%35#0 0' +debug: Replaced test_cases.structure_methods.contract.TestContract.test_block@3.ops[173]: 'v-load aggregate%as_Encoded(uint64)%35#0' with 'l-load aggregate%as_Encoded(uint64)%35#0' +debug: Inserted test_cases.structure_methods.contract.TestContract.test_block@3.ops[178]: 'l-store-copy event%6#0 0' +debug: Replaced test_cases.structure_methods.contract.TestContract.test_block@3.ops[180]: 'v-load event%6#0' with 'l-load event%6#0' +debug: Inserted test_cases.structure_methods.contract.TestContract.test_block@3.ops[184]: 'l-store-copy aggregate%val_as_bytes%17#0 0' +debug: Replaced test_cases.structure_methods.contract.TestContract.test_block@3.ops[186]: 'v-load aggregate%val_as_bytes%17#0' with 'l-load aggregate%val_as_bytes%17#0' +debug: Inserted test_cases.structure_methods.contract.TestContract.test_block@3.ops[187]: 'l-store-copy aggregate%as_Encoded(uint64)%36#0 0' +debug: Replaced test_cases.structure_methods.contract.TestContract.test_block@3.ops[189]: 'v-load aggregate%as_Encoded(uint64)%36#0' with 'l-load aggregate%as_Encoded(uint64)%36#0' +debug: Inserted test_cases.structure_methods.contract.TestContract.test_block@3.ops[194]: 'l-store-copy aggregate%head%19#0 0' +debug: Replaced test_cases.structure_methods.contract.TestContract.test_block@3.ops[196]: 'v-load aggregate%head%19#0' with 'l-load aggregate%head%19#0' +debug: Inserted test_cases.structure_methods.contract.TestContract.test_block@3.ops[197]: 'l-store-copy aggregate%as_Encoded(uint64)%37#0 0' +debug: Replaced test_cases.structure_methods.contract.TestContract.test_block@3.ops[199]: 'v-load aggregate%as_Encoded(uint64)%37#0' with 'l-load aggregate%as_Encoded(uint64)%37#0' +debug: Inserted test_cases.structure_methods.contract.TestContract.test_block@3.ops[204]: 'l-store-copy event%7#0 0' +debug: Replaced test_cases.structure_methods.contract.TestContract.test_block@3.ops[206]: 'v-load event%7#0' with 'l-load event%7#0' +debug: Inserted test_cases.structure_methods.contract.TestContract.test_block@3.ops[8]: 'l-store-copy tmp%0#0 0' +debug: Replaced test_cases.structure_methods.contract.TestContract.test_block@3.ops[11]: 'v-load tmp%0#0' with 'l-load tmp%0#0' +debug: Inserted test_cases.structure_methods.contract.TestContract.test_block@3.ops[19]: 'l-store-copy tmp%1#1 0' +debug: Replaced test_cases.structure_methods.contract.TestContract.test_block@3.ops[22]: 'v-load tmp%1#1' with 'l-load tmp%1#1' +debug: Inserted test_cases.structure_methods.contract.TestContract.test_block@3.ops[36]: 'l-store-copy tmp%2#0 0' +debug: Replaced test_cases.structure_methods.contract.TestContract.test_block@3.ops[39]: 'v-load tmp%2#0' with 'l-load tmp%2#0' +debug: Inserted test_cases.structure_methods.contract.TestContract.test_block@3.ops[47]: 'l-store-copy tmp%3#1 0' +debug: Replaced test_cases.structure_methods.contract.TestContract.test_block@3.ops[50]: 'v-load tmp%3#1' with 'l-load tmp%3#1' +debug: Inserted test_cases.structure_methods.contract.TestContract.test_block@3.ops[64]: 'l-store-copy tmp%4#1 0' +debug: Replaced test_cases.structure_methods.contract.TestContract.test_block@3.ops[67]: 'v-load tmp%4#1' with 'l-load tmp%4#1' +debug: Inserted test_cases.structure_methods.contract.TestContract.test_block@3.ops[75]: 'l-store-copy tmp%5#1 0' +debug: Replaced test_cases.structure_methods.contract.TestContract.test_block@3.ops[78]: 'v-load tmp%5#1' with 'l-load tmp%5#1' +debug: Inserted test_cases.structure_methods.contract.TestContract.test_block@3.ops[92]: 'l-store-copy tmp%6#0 0' +debug: Replaced test_cases.structure_methods.contract.TestContract.test_block@3.ops[95]: 'v-load tmp%6#0' with 'l-load tmp%6#0' +debug: Inserted test_cases.structure_methods.contract.TestContract.test_block@3.ops[103]: 'l-store-copy tmp%7#1 0' +debug: Replaced test_cases.structure_methods.contract.TestContract.test_block@3.ops[106]: 'v-load tmp%7#1' with 'l-load tmp%7#1' +debug: Inserted test_cases.structure_methods.contract.TestContract.test_block@3.ops[120]: 'l-store-copy tmp%8#0 0' +debug: Replaced test_cases.structure_methods.contract.TestContract.test_block@3.ops[123]: 'v-load tmp%8#0' with 'l-load tmp%8#0' +debug: Inserted test_cases.structure_methods.contract.TestContract.test_block@3.ops[131]: 'l-store-copy tmp%9#1 0' +debug: Replaced test_cases.structure_methods.contract.TestContract.test_block@3.ops[134]: 'v-load tmp%9#1' with 'l-load tmp%9#1' +debug: Inserted test_cases.structure_methods.contract.TestContract.test_block@3.ops[148]: 'l-store-copy tmp%10#1 0' +debug: Replaced test_cases.structure_methods.contract.TestContract.test_block@3.ops[151]: 'v-load tmp%10#1' with 'l-load tmp%10#1' +debug: Inserted test_cases.structure_methods.contract.TestContract.test_block@3.ops[159]: 'l-store-copy tmp%11#1 0' +debug: Replaced test_cases.structure_methods.contract.TestContract.test_block@3.ops[162]: 'v-load tmp%11#1' with 'l-load tmp%11#1' +debug: Inserted test_cases.structure_methods.contract.TestContract.test_block@3.ops[176]: 'l-store-copy tmp%12#1 0' +debug: Replaced test_cases.structure_methods.contract.TestContract.test_block@3.ops[179]: 'v-load tmp%12#1' with 'l-load tmp%12#1' +debug: Inserted test_cases.structure_methods.contract.TestContract.test_block@3.ops[187]: 'l-store-copy tmp%13#1 0' +debug: Replaced test_cases.structure_methods.contract.TestContract.test_block@3.ops[190]: 'v-load tmp%13#1' with 'l-load tmp%13#1' +debug: Inserted test_cases.structure_methods.contract.TestContract.test_block@3.ops[204]: 'l-store-copy tmp%14#1 0' +debug: Replaced test_cases.structure_methods.contract.TestContract.test_block@3.ops[207]: 'v-load tmp%14#1' with 'l-load tmp%14#1' +debug: Inserted test_cases.structure_methods.contract.TestContract.test_block@3.ops[215]: 'l-store-copy tmp%15#1 0' +debug: Replaced test_cases.structure_methods.contract.TestContract.test_block@3.ops[218]: 'v-load tmp%15#1' with 'l-load tmp%15#1' +debug: test_cases.structure_methods.contract.TestContract.test f-stack entry: [] +debug: test_cases.structure_methods.contract.TestContract.test f-stack on first store: ['return_value_times%1#0', 'return_value_times%3#0', 'return_value_times%5#0', 'return_value_times%7#0'] +debug: optimizing TEAL subroutine ops algopy.arc4.ARC4Contract.approval_program() -> uint64: +structure_methods/contract.py:9:5 debug: optimizing TEAL subroutine ops test_cases.structure_methods.contract.ARC4TestStruct.return_value_times(self: bytes, times: uint64) -> uint64, bytes: +structure_methods/contract.py:12:6 debug: optimizing TEAL subroutine ops test_cases.structure_methods.contract.ARC4TestStruct.return1() -> uint64: +structure_methods/contract.py:20:5 debug: optimizing TEAL subroutine ops test_cases.structure_methods.contract.TestStruct.return_value_times(self: bytes, times: uint64) -> uint64, bytes: +structure_methods/contract.py:23:6 debug: optimizing TEAL subroutine ops test_cases.structure_methods.contract.TestStruct.return1() -> uint64: +structure_methods/contract.py:31:5 debug: optimizing TEAL subroutine ops test_cases.structure_methods.contract.TestNamedTuple.return_value_times(self.value: uint64, times: uint64) -> uint64: +structure_methods/contract.py:34:6 debug: optimizing TEAL subroutine ops test_cases.structure_methods.contract.TestNamedTuple.return1() -> uint64: +structure_methods/contract.py:40:6 debug: optimizing TEAL subroutine ops test_cases.structure_methods.contract.GroupedMethods.never_inlined_usually_inlined(v: uint64) -> uint64: +structure_methods/contract.py:55:5 debug: optimizing TEAL subroutine ops test_cases.structure_methods.contract.GroupedMethods.usually_inlined(v: uint64) -> uint64: +structure_methods/contract.py:58:5 debug: optimizing TEAL subroutine ops test_cases.structure_methods.contract.GroupedMethods.not_usually_inlined(v: uint64) -> void: +structure_methods/contract.py:70:6 debug: optimizing TEAL subroutine ops test_cases.structure_methods.contract.TestContract.test[routing]() -> void: +structure_methods/contract.py:70:6 debug: optimizing TEAL subroutine ops test_cases.structure_methods.contract.TestContract.test() -> void: +debug: optimizing TEAL subroutine ops algopy.arc4.ARC4Contract.clear_state_program() -> uint64: +info: Writing structure_methods/out_unoptimized/TestContract.approval.teal +info: Writing structure_methods/out_unoptimized/TestContract.clear.teal +info: Writing structure_methods/out_unoptimized/TestContract.approval.bin +info: Writing structure_methods/out_unoptimized/TestContract.clear.bin +info: Writing structure_methods/out_unoptimized/TestContract.approval.stats.txt +info: Writing structure_methods/out_unoptimized/TestContract.clear.stats.txt +info: Writing structure_methods/out_unoptimized/TestContract.approval.puya.map +info: Writing structure_methods/out_unoptimized/TestContract.clear.puya.map \ No newline at end of file